create_job_template ¶

def create_job_template(
    self,
    *,
    config_overrides: Optional[MediaConvertClientConfig] = None,
    acceleration_settings: Optional[
        "capo_mediaconvert.types.acceleration_settings.AccelerationSettings"
    ] = None,
    category: Optional["capo_mediaconvert.types.__string.__string"] = None,
    description: Optional["capo_mediaconvert.types.__string.__string"] = None,
    hop_destinations: Optional[
        "capo_mediaconvert.types.__list_of_hop_destination.__listOfHopDestination"
    ] = None,
    name: Optional["capo_mediaconvert.types.__string.__string"] = None,
    priority: Optional[
        "capo_mediaconvert.types.__integer_min_negative50_max50.__integerMinNegative50Max50"
    ] = None,
    queue: Optional["capo_mediaconvert.types.__string.__string"] = None,
    settings: Optional[
        "capo_mediaconvert.types.job_template_settings.JobTemplateSettings"
    ] = None,
    status_update_interval: Optional[
        "capo_mediaconvert.types.status_update_interval.StatusUpdateInterval"
    ] = None,
    tags: Optional[
        "capo_mediaconvert.types.__map_of__string.__mapOf__string"
    ] = None,
) -> (
    "capo_mediaconvert.types.create_job_template_response.CreateJobTemplateResponse"
):
    """Create a new job template. For information about job templates see the User Guide at http://docs.aws.amazon.com/mediaconvert/latest/ug/what-is.html

    Args:
        acceleration_settings: Accelerated transcoding can significantly speed up jobs with long, visually complex content. Outputs that use this feature incur pro-tier pricing. For information about feature limitations, see the AWS Elemental MediaConvert User Guide.
        category: Optional. A category for the job template you are creating
        description: Optional. A description of the job template you are creating.
        hop_destinations: Optional. Use queue hopping to avoid overly long waits in the backlog of the queue that you submit your job to. Specify an alternate queue and the maximum time that your job will wait in the initial queue before hopping. For more information about this feature, see the AWS Elemental MediaConvert User Guide.
        name: The name of the job template you are creating.
        priority: Specify the relative priority for this job. In any given queue, the service begins processing the job with the highest value first. When more than one job has the same priority, the service begins processing the job that you submitted first. If you don't specify a priority, the service uses the default value 0.
        queue: Optional. The queue that jobs created from this template are assigned to. If you don't specify this, jobs will go to the default queue.
        settings: JobTemplateSettings contains all the transcode settings saved in the template that will be applied to jobs created from it.
        status_update_interval: Specify how often MediaConvert sends STATUS_UPDATE events to Amazon CloudWatch Events. Set the interval, in seconds, between status updates. MediaConvert sends an update at this interval from the time the service begins processing your job to the time it completes the transcode or encounters an error.
        tags: The tags that you want to add to the resource. You can tag resources with a key-value pair or with only a key.

    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.create_job_template_request.CreateJobTemplateRequest]",
    ) -> OperationResponse[
        "capo_mediaconvert.types.create_job_template_response.CreateJobTemplateResponse"
    ]:
        import capo_mediaconvert._operations.media_convert.create_job_template

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

    interceptors_, options_ = self.operation_options(
        config_overrides, OperationLogging("CreateJobTemplate")
    )
    input_: capo_mediaconvert.types.create_job_template_request.CreateJobTemplateRequest = {}
    if acceleration_settings is not None:
        input_["acceleration_settings"] = acceleration_settings
    if category is not None:
        input_["category"] = category
    if description is not None:
        input_["description"] = description
    if hop_destinations is not None:
        input_["hop_destinations"] = hop_destinations
    if name is not None:
        input_["name"] = name
    if priority is not None:
        input_["priority"] = priority
    if queue is not None:
        input_["queue"] = queue
    if settings is not None:
        input_["settings"] = settings
    if status_update_interval is not None:
        input_["status_update_interval"] = status_update_interval
    if tags is not None:
        input_["tags"] = tags

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