# -*- coding: utf-8 -*-

from mpc import mpc_client
from mpc import template_model
from mpc import task_model
from common.exception.mpc_sdk_exception import MPCSDKException


def createTrancodeTemplate():
    """createTrancodeTemplate 创建转码模板调用SDK实例

    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("YE5FAQPMLZM3CLBNTAY6","yszla7OKRdkcuDsoENRrNHEe6EFuMhYSRgezOQLx",
                                      "mts.cn-north-1.myhuaweicloud.com","58411d8df90649a39b75d75b54e01735")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = template_model.TransTemplate()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
        params = '''{
            "template_name": "MP4_H.264_1920x1080_6000_HEAAC1_x666",
            "video": {
                "codec": 1,
                "width": 0,
                "height": 0,
                "frame_rate": 1,
                "black_cut": 0,
                "profile": 3,
                "level": 15,
                "preset": 3,
                "bitrate": 200,
                "max_iframes_interval": 5,
                "bframes_count": 4,
                "ref_frames_count": 4
            },
            "audio": {
                "codec": 1,
                "sample_rate": 1,
                "channels": 2,
                "bitrate": 0
            },
            "common": {
                "PVC": true,
                "pack_type": 4,
                "hls_interval": 5,
                "dash_interval": 5
            }
        }'''

        req.from_json_string(params)

        # 通过client对象调用CreateTranscodeTemplate方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个CreateTemplateResponse类的实例，与请求对象对应。
        resp = client.CreateTranscodeTemplate(req)

        # 打印响应
        print("=====createTrancodeTemplate resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)
        

def updateTrancodeTemplate():
    """updateTrancodeTemplate 更新转码模板调用SDK实例

    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("YE5FAQPMLZM3CLBNTAY6","yszla7OKRdkcuDsoENRrNHEe6EFuMhYSRgezOQLx",
                                      "mts.cn-north-1.myhuaweicloud.com","58411d8df90649a39b75d75b54e01735")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = template_model.TransTemplate()

        # 填充请求参数,这里request对象的成员变量即对应接口的入参。
        # 你可以通过官网接口文档或跳转到request对象的定义处查看请求参数的定义。
        req.template_id = 4
        req.template_name = "MP4_H.265_1920x1080_6000_HEAAC1_x4"

        video = template_model.Video()
        video.codec = 2
        video.width = 1920
        video.height = 1080
        video.frame_rate = 1
        video.black_cut = 1
        video.profile = 4
        video.level = 14
        video.preset = 1
        video.bitrate = 0
        video.max_iframes_interval = 5
        video.bframes_count = 7
        video.ref_frames_count = 4
        req.video = video

        audio = template_model.Audio()
        audio.codec = 1
        audio.bitrate = 0
        audio.channels = 2
        audio.sample_rate = 1
        req.audio = audio

        common = template_model.Common()
        common.PVC = bool(1)
        common.pack_type = 3
        common.hls_interval = 5
        common.dash_interval = 5
        req.common = common

        # 通过client对象调用UpdateTranscodeTemplate方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个BaseResponse类的实例，与请求对象对应。
        resp = client.UpdateTranscodeTemplate(req)

        # 打印响应
        print("=====updateTrancodeTemplate resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)


def queryOneTrancodeTemplate():
    """queryOneTrancodeTemplate 查询单个转码模板调用SDK实例

    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("YE5FAQPMLZM3CLBNTAY6","yszla7OKRdkcuDsoENRrNHEe6EFuMhYSRgezOQLx",
                                      "mts.cn-north-1.myhuaweicloud.com","58411d8df90649a39b75d75b54e01735")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = template_model.QueryTemplateRequest()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
        req.template_id = 30928

        # 通过client对象调用QueryTranscodeTemplates方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个QueryTranscodeTemplateResponse类的实例，与请求对象对应。
        resp = client.QueryTranscodeTemplates(req)

        # 打印响应
        print("=====queryOneTrancodeTemplate resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

def queryManyTrancodeTemplate():
    """queryManyTrancodeTemplate 查询多个转码模板调用SDK实例

    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("YE5FAQPMLZM3CLBNTAY6","yszla7OKRdkcuDsoENRrNHEe6EFuMhYSRgezOQLx",
                                      "mts.cn-north-1.myhuaweicloud.com","58411d8df90649a39b75d75b54e01735")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = template_model.QueryTemplateRequest()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
        req.template_id = [472, 6985, 12]

        # 通过client对象调用QueryTranscodeTemplates方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个QueryTranscodeTemplateResponse类的实例，与请求对象对应。
        resp = client.QueryTranscodeTemplates(req)

        # 打印响应
        print("=====queryManyTrancodeTemplate resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

def queryAllTrancodeTemplate():
    """queryAllTrancodeTemplate 查询所有转码模板调用SDK实例

    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("YE5FAQPMLZM3CLBNTAY6","yszla7OKRdkcuDsoENRrNHEe6EFuMhYSRgezOQLx",
                                      "mts.cn-north-1.myhuaweicloud.com","58411d8df90649a39b75d75b54e01735")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = template_model.QueryTemplateRequest()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
#        req.template_id = [6984, 6985, 6986]

        # 通过client对象调用QueryTranscodeTemplates方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个QueryTranscodeTemplateResponse类的实例，与请求对象对应。
        resp = client.QueryTranscodeTemplates(req)

        # 打印响应
        print("=====queryAllTrancodeTemplate resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

def queryTrancodeTemplateByPageAndSize():
    """queryTrancodeTemplateByPageAndSize 根据page和size查询水印查询转码模板调用SDK实例

    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("YE5FAQPMLZM3CLBNTAY6","yszla7OKRdkcuDsoENRrNHEe6EFuMhYSRgezOQLx",
                                      "mts.cn-north-1.myhuaweicloud.com","58411d8df90649a39b75d75b54e01735")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = template_model.QueryTemplateRequest()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
        req.page = 0
        req.size = 2

        # 通过client对象调用QueryTranscodeTemplates方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个QueryTranscodeTemplateResponse类的实例，与请求对象对应。
        resp = client.QueryTranscodeTemplates(req)

        # 打印响应
        print("=====queryTrancodeTemplateByPageAndSize resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

def deleteTrancodeTemplate():
    """deleteTrancodeTemplate 删除转码模板调用SDK实例

    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("YE5FAQPMLZM3CLBNTAY6","yszla7OKRdkcuDsoENRrNHEe6EFuMhYSRgezOQLx",
                                      "mts.cn-north-1.myhuaweicloud.com","58411d8df90649a39b75d75b54e01735")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = template_model.DeleteTemplateRequest()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
        req.template_id = 1

        # 通过client对象调用DeleteTranscodeTemplate方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个BaseResponse类的实例，与请求对象对应。
        resp = client.DeleteTranscodeTemplate(req)

        # 打印响应
        print("=====deleteTrancodeTemplate resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

def updateWatermarkTemplate():
    """updateWatermarkTemplate 更新水印模板调用SDK实例

    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("YE5FAQPMLZM3CLBNTAY6","yszla7OKRdkcuDsoENRrNHEe6EFuMhYSRgezOQLx",
                                      "mts.cn-north-1.myhuaweicloud.com","58411d8df90649a39b75d75b54e01735")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = template_model.WatermarkTemplate()

        # 填充请求参数,这里request对象的成员变量即对应接口的入参。
        # 你可以通过官网接口文档或跳转到request对象的定义处查看请求参数的定义。
        params = '''{
            "template_name": "1",
            "type": "Image",
            "image_process": "Transparent",
            "width": "1920",
            "height": "1080",
            "dx": "0.1",
            "dy": "10",
            "referpos": "BottomRight",
            "timeline_start": "6",
            "timeline_duration": "600"
        }'''

        req.from_json_string(params)

        # 通过client对象调用UpdateWatermarkTemplate方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个BaseResponse类的实例，与请求对象对应。
        resp = client.UpdateWatermarkTemplate(req)

        # 打印响应
        print("=====updateWatermarkTemplate resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

def createWatermarkTemplate():
    """createWatermarkTemplate 创建水印模板调用SDK实例

    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("3CV7HEQKJYO2HUSWPBGD", "BZbmnAuSebO75zk1MHnHWopg67z1msnuCtjpWpbl",
                                      "mts.cn-north-1.myhuaweicloud.com", "093bb6b6c4fc460ab90a40d8b821dda3")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = template_model.WatermarkTemplate()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
        req.template_id = 1
        req.template_name = "watermark_test"
        req.type = "Image"
        req.width = "0.3"
        req.height = "800"
        req.dx = "0.2"
        req.dy = "20"
        req.image_process = "Grayed"
        req.referpos = "BottomLeft"
        req.timeline_start = "2"
        req.timeline_duration = "10"

        # 通过client对象调用CreateWatermarkTemplate方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个CreateTemplateResponse类的实例，与请求对象对应。
        resp = client.CreateWatermarkTemplate(req)

        # 打印响应
        print("=====createWatermarkTemplate resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

def queryOneWatermarkTemplate():
    """queryOneWatermarkTemplate 查询单个水印模板调用SDK实例

    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("YE5FAQPMLZM3CLBNTAY6","yszla7OKRdkcuDsoENRrNHEe6EFuMhYSRgezOQLx",
                                      "mts.cn-north-1.myhuaweicloud.com","58411d8df90649a39b75d75b54e01735")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = template_model.QueryTemplateRequest()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
        req.template_id = 1

        # 通过client对象调用QueryWatermarkTemplates方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个QueryWatermarkTemplateResponse类的实例，与请求对象对应。
        resp = client.QueryWatermarkTemplates(req)

        # 打印响应
        print("=====queryOneWatermarkTemplate resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

def queryManyWatermarkTemplate():
    """queryManyWatermarkTemplate 查询多个水印模板调用SDK实例

    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("YE5FAQPMLZM3CLBNTAY6","yszla7OKRdkcuDsoENRrNHEe6EFuMhYSRgezOQLx",
                                      "mts.cn-north-1.myhuaweicloud.com","58411d8df90649a39b75d75b54e01735")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = template_model.QueryTemplateRequest()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
        req.template_id = [1, 2]

        # 通过client对象调用QueryWatermarkTemplates方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个QueryWatermarkTemplateResponse类的实例，与请求对象对应。
        resp = client.QueryWatermarkTemplates(req)

        # 打印响应
        print("=====queryManyWatermarkTemplate resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

def queryAllWatermarkTemplate():
    """queryAllWatermarkTemplate 查询所有水印模板调用SDK实例

    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("YE5FAQPMLZM3CLBNTAY6","yszla7OKRdkcuDsoENRrNHEe6EFuMhYSRgezOQLx",
                                      "mts.cn-north-1.myhuaweicloud.com","58411d8df90649a39b75d75b54e01735")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = template_model.QueryTemplateRequest()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
#        req.template_id = [1, 2]

        # 通过client对象调用QueryWatermarkTemplates方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个QueryWatermarkTemplateResponse类的实例，与请求对象对应。
        resp = client.QueryWatermarkTemplates(req)

        # 打印响应
        print("=====queryAllWatermarkTemplate resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

def queryWatermarkTemplateByPageAndSize():
    """queryWatermarkTemplateByPageAndSize 根据page和size查询水印模板调用SDK实例

    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("YE5FAQPMLZM3CLBNTAY6","yszla7OKRdkcuDsoENRrNHEe6EFuMhYSRgezOQLx",
                                      "mts.cn-north-1.myhuaweicloud.com","58411d8df90649a39b75d75b54e01735")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = template_model.QueryTemplateRequest()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
        req.page = 0
        req.size = 2

        # 通过client对象调用QueryWatermarkTemplates方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个QueryWatermarkTemplateResponse类的实例，与请求对象对应。
        resp = client.QueryWatermarkTemplates(req)

        # 打印响应
        print("=====queryTrancodeTemplateByPageAndSize resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

def deleteWatermarkTemplate():
    """deleteWatermarkTemplate 删除水印模板调用SDK实例

    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("YE5FAQPMLZM3CLBNTAY6","yszla7OKRdkcuDsoENRrNHEe6EFuMhYSRgezOQLx",
                                      "mts.cn-north-1.myhuaweicloud.com","58411d8df90649a39b75d75b54e01735")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = template_model.DeleteTemplateRequest()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
        req.template_id = 1

        # 通过client对象调用DeleteWatermarkTemplate方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个BaseResponse类的实例，与请求对象对应。
        resp = client.DeleteWatermarkTemplate(req)

        # 打印响应
        print("=====deleteWatermarkTemplate resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

def createTranscodeTaskByBatch():
    """createTrancodeTask 创建转码任务调用SDK实例

    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("3CV7HEQKJYO2HUSWPBGD","BZbmnAuSebO75zk1MHnHWopg67z1msnuCtjpWpbl",
                                      "mts.cn-north-1.myhuaweicloud.com","093bb6b6c4fc460ab90a40d8b821dda3")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = task_model.CreateTranscodeTaskRequest()
        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
        params = '''{
            "input": {
                "bucket": "lihaiou-02",
                "location": "cn-north-1",
                "object": "fczlm.mp4"
            },
            "output": {
                "bucket": "lihaiou-02",
                "location": "cn-north-1",
                "object": "zhihu"
            },
            "trans_template_id": [7000800],
            "priority": "9",
            "av_parameters": [{
                "video": {
                    "codec": 1,
                    "width": 0,
                    "height": 0,
                    "frame_rate": 1,
                    "black_cut": 0,
                    "profile": 3,
                    "level": 15,
                    "preset": 3,
                    "bitrate": 200,
                    "max_iframes_interval": 5,
                    "bframes_count": 4,
                    "ref_frames_count": 4
                },
                "common": {
                           "PVC": true,
                           "pack_type": 4,
                           "hls_interval": 5,
                           "dash_interval": 5
                       },
                "audio": {
                    "codec": 1,
                    "sample_rate": 1,
                    "channels": 2,
                    "bitrate": 0
                }
            }],
            "watermarks": [{
                "input": {
                    "bucket": "lihaiou-02",
                    "location": "cn-north-1",
                    "object": "秒拍.png"
                },
                "image_watermark": {
                    "image_process": "Transparent",
                    "width": "480",
                    "height": "270",
                    "dx": "0",
                    "dy": "0",
                    "referpos": "TopRight",
                    "timeline_start": "0",
                    "timeline_duration": "ToEND"
                }
            }]
        }'''

        req.from_json_string(params)

        req2 = task_model.CreateTranscodeTaskRequest()
        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
        params = '''{
                   "input": {
                       "bucket": "lihaiou-02",
                       "location": "cn-north-1",
                       "object": "1_H.264_128X72_HEAACV1_401.mp4"
                   },
                   "output": {
                       "bucket": "lihaiou-02",
                       "location": "cn-north-1",
                       "object": "xxxx"
                   },
                   "trans_template_id": [7000800],
                   "priority": "9",
                   "av_parameters": [{
                       "video": {
                           "codec": 1,
                           "width": 0,
                           "height": 0,
                           "frame_rate": 1,
                           "black_cut": 0,
                           "profile": 3,
                           "level": 15,
                           "preset": 3,
                           "bitrate": 200,
                           "max_iframes_interval": 5,
                           "bframes_count": 4,
                           "ref_frames_count": 4
                       },
                       "common": {
                           "PVC": true,
                           "pack_type": 4,
                           "hls_interval": 5,
                           "dash_interval": 5
                       },
                       "audio": {
                           "codec": 1,
                           "sample_rate": 1,
                           "channels": 2,
                           "bitrate": 0
                       }
                   }]
               }'''

        req2.from_json_string(params)

        req_arr = []
        req_arr.append(req)
       # req_arr.append(req2)



        # 通过client对象调用CreateTranscodeTaskRequest方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个CreateTaskResponse类的实例，与请求对象对应。
        resp = client.CreateBatchTranscodeTask(req_arr)

        # 打印响应
        print("=====CreateBatchTranscodeTask resp")
        for item in resp.task_array:
            print(item._serialize())

    except MPCSDKException as e:
        print(e)


def createTrancodeTask():
    """createTrancodeTask 创建转码任务调用SDK实例

    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("XRHGX6EIARPIVSNGHAFX", "UA1wHt2q4z1GrA8h6yf3iISTWzQeNm3WXK6j8Cn3",
                                      "mts.cn-north-1.myhuaweicloud.com", "093bb6b6c4fc460ab90a40d8b821dda3")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = task_model.CreateTranscodeTaskRequest()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
        params = '''{
                "input": {
                           "bucket": "lihaiou-02",
                           "location": "cn-north-1",
                           "object": "1_H.264_128X72_HEAACV1_401.mp4"
                },
                "output": {
                           "bucket": "lihaiou-02",
                           "location": "cn-north-1",
                           "object": "test/"
                },
                "trans_template_id":[236703],
                "watermarks": [
                    {
                        "input": {
                        	"bucket": "lihaiou-02",
                        	"location": "cn-north-1",
                        	"object": "input/shuiyin.png"
                        	
                        },
                        "image_watermark": {
                            "image_process": "Transparent",
                            "base": "output",
                            "dx": 45,
                            "dy": 40,
                            "referpos": "TopRight",
                            "width": 108,
                            "height": 720
                        }
                    }
                ]
            } '''

        req.from_json_string(params)

        # 通过client对象调用CreateTranscodeTaskRequest方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个CreateTaskResponse类的实例，与请求对象对应。
        resp = client.CreateTranscodeTask(req)

        # 打印响应
        print("=====createTrancodeTask resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

def queryTrancodeDetailTask():
    """queryTrancodeDetailTask 查询转码任务调用SDK实例

    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("3CV7HEQKJYO2HUSWPBGD","BZbmnAuSebO75zk1MHnHWopg67z1msnuCtjpWpbl",
                                      "mts.cn-north-1.myhuaweicloud.com","093bb6b6c4fc460ab90a40d8b821dda3")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = task_model.QueryTaskDetailRequest()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
        #req.task_id = [6277558]
        req.task_id = [6262097,6340258,6340259]
        # 通过client对象调用QueryTaskRequest方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个QueryTaskResponse类的实例，与请求对象对应。
        resp = client.QueryTranscodeDetailTasks(req)

        # 打印响应
        print("=====QueryTranscodeDetailTasks resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

def queryOneTrancodeTask():
    """queryOneTrancodeTask 查询单个转码任务调用SDK实例

    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("YE5FAQPMLZM3CLBNTAY6","yszla7OKRdkcuDsoENRrNHEe6EFuMhYSRgezOQLx",
                                      "mts.cn-north-1.myhuaweicloud.com","58411d8df90649a39b75d75b54e01735")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = task_model.QueryTaskRequest()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
        req.task_id = 324

        # 通过client对象调用QueryTaskRequest方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个QueryTaskResponse类的实例，与请求对象对应。
        resp = client.QueryTranscodeTasks(req)

        # 打印响应
        print("=====queryOneTrancodeTask resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

def queryManyTrancodeTask():
    """queryManyTrancodeTask 查询多个转码任务调用SDK实例

    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("YE5FAQPMLZM3CLBNTAY6","yszla7OKRdkcuDsoENRrNHEe6EFuMhYSRgezOQLx",
                                      "mts.cn-north-1.myhuaweicloud.com","58411d8df90649a39b75d75b54e01735")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = task_model.QueryTaskRequest()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
        req.task_id = [1, 300, 607]

        # 通过client对象调用QueryTaskRequest方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个QueryTaskResponse类的实例，与请求对象对应。
        resp = client.QueryTranscodeTasks(req)

        # 打印响应
        print("=====queryManyTrancodeTask resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

def queryTrancodeTaskByPageAndSize():
    """queryTrancodeTaskByPageAndSize 根据page和size查询多个转码任务调用SDK实例

    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("YE5FAQPMLZM3CLBNTAY6","yszla7OKRdkcuDsoENRrNHEe6EFuMhYSRgezOQLx",
                                      "mts.cn-north-1.myhuaweicloud.com","58411d8df90649a39b75d75b54e01735")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = task_model.QueryTaskRequest()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
        req.page = 1
        req.size = 100

        # 通过client对象调用QueryTaskRequest方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个QueryTaskResponse类的实例，与请求对象对应。
        resp = client.QueryTranscodeTasks(req)

        # 打印响应
        print("=====queryTrancodeTaskByPageAndSize resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

def queryAllTrancodeTask():
    """queryAllTrancodeTask 查询所有转码任务调用SDK实例

    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("VR0ITIZSYVYG5EUXK3BK","FQNZv1liSqm5CeIfySjyQDcAV4Vmf9va2p11G8ij",
                                      "mts.cn-north-1.myhuaweicloud.com","58411d8df90649a39b75d75b54e01735")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = task_model.QueryTaskRequest()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
#        req.task_id = 1

        # 通过client对象调用QueryTaskRequest方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个QueryTaskResponse类的实例，与请求对象对应。
        resp = client.QueryTranscodeTasks(req)

        # 打印响应
        print("=====queryAllTrancodeTask resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

def deleteTrancodeTask():
    """deleteTrancodeTask 删除转码任务调用SDK实例

    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("YE5FAQPMLZM3CLBNTAY6","yszla7OKRdkcuDsoENRrNHEe6EFuMhYSRgezOQLx",
                                      "mts.cn-north-1.myhuaweicloud.com","58411d8df90649a39b75d75b54e01735")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = task_model.DeleteTaskRequest()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
        req.task_id = 324

        # 通过client对象调用DeleteTranscodeTask方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个BaseResponse类的实例，与请求对象对应。
        resp = client.DeleteTranscodeTask(req)

        # 打印响应
        print("=====deleteTrancodeTask resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

def createThumbnailTask():
    """createThumbnailTask 创建截图任务调用SDK实例

    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("3CV7HEQKJYO2HUSWPBGD","BZbmnAuSebO75zk1MHnHWopg67z1msnuCtjpWpbl",
                                      "mts.cn-north-1.myhuaweicloud.com","093bb6b6c4fc460ab90a40d8b821dda3")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = task_model.CreateThumbnailTaskRequest()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
        params = '''{
                      "input": {
                           "bucket": "lihaiou-02",
                           "location": "cn-north-1",
                           "object": "1_H.264_128X72_HEAACV1_401.mp4"
                      },
                      "output": {
                           "bucket": "lihaiou-02",
                           "location": "cn-north-1",
                           "object": "test/"
                      },
                      "thumbnail_para": {
                                 "type": "DOTS",
                                 "time": 12,
                                 "start_time": 0,
                                 "duration": 0,
                                 "dots": [
                                   1
                                 ],
                                 "format": 0,
                                 "aspect_ratio": 0,
                                 "width": 854,
                                 "height": 480,
                                 "max_length": 480
                      },
                     "tar": 0,
                     "sync": 1
                  } '''

        req.from_json_string(params)

        # 通过client对象调用CreateThumbnailTask方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个CreateTaskResponse类的实例，与请求对象对应。
        resp = client.CreateThumbnailTask(req)

        # 打印响应
        print("=====CreateThumbnailTask resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

def queryThumbnailTask():
    """queryThumbnailTask 查询截图任务调用SDK实例
    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("3CV7HEQKJYO2HUSWPBGD","BZbmnAuSebO75zk1MHnHWopg67z1msnuCtjpWpbl",
                                      "mts.cn-north-1.myhuaweicloud.com","093bb6b6c4fc460ab90a40d8b821dda3")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = task_model.QueryTaskRequest()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
        req.task_id = [1, 300, 607]

        # 通过client对象调用QueryThumbnailTask方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个QueryTaskResponse类的实例，与请求对象对应。
        resp = client.QueryThumbnailTask(req)

        # 打印响应
        print("=====QueryThumbnailTask resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

def deleteThumbnailTask():
    """deleteThumbnailTask 删除截图任务调用SDK实例

    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("3CV7HEQKJYO2HUSWPBGD","BZbmnAuSebO75zk1MHnHWopg67z1msnuCtjpWpbl",
                                      "mts.cn-north-1.myhuaweicloud.com","093bb6b6c4fc460ab90a40d8b821dda3")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = task_model.DeleteStrTaskRequest()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
        req.task_id = 324

        # 通过client对象调用DeleteThumbnailTask方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个BaseResponse类的实例，与请求对象对应。
        resp = client.DeleteThumbnailTask(req)

        # 打印响应
        print("=====DeleteThumbnailTask resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

def createRemuxTask():
    """createRemuxTask 下发转封装任务调用SDK实例

    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("3CV7HEQKJYO2HUSWPBGD","BZbmnAuSebO75zk1MHnHWopg67z1msnuCtjpWpbl",
                                      "mts.cn-north-1.myhuaweicloud.com","093bb6b6c4fc460ab90a40d8b821dda3")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = task_model.CreateRemuxTaskRequest()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
        params = '''{
                      "input": {
                           "bucket": "lihaiou-02",
                           "location": "cn-north-1",
                           "object": "1_H.264_128X72_HEAACV1_401.mp4"
                      },
                      "output": {
                           "bucket": "lihaiou-02",
                           "location": "cn-north-1",
                           "object": "test/"
                      },
                      "output_param": {
                           "format": "HLS",
                           "segment_duration": 10
                      }
                  } '''

        req.from_json_string(params)

        # 通过client对象调用CreateExtractTask方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个CreateTaskResponse类的实例，与请求对象对应。
        resp = client.CreateRemuxTask(req)

        # 打印响应
        print("=====CreateRemuxTask resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

def queryRemuxTask():
    """queryRemuxTask 查询转封装任务调用SDK实例
    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("3CV7HEQKJYO2HUSWPBGD","BZbmnAuSebO75zk1MHnHWopg67z1msnuCtjpWpbl",
                                      "mts.cn-north-1.myhuaweicloud.com","093bb6b6c4fc460ab90a40d8b821dda3")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = task_model.QueryTaskRequest()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
        req.task_id = [1, 300, 607]

        # 通过client对象调用QueryExtractTask方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个QueryTaskResponse类的实例，与请求对象对应。
        resp = client.QueryRemuxTask(req)

        # 打印响应
        print("=====queryRemuxTask resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

def deleteRemuxTask():
    """deleteRemuxTask 删除转封装任务调用SDK实例

    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("3CV7HEQKJYO2HUSWPBGD","BZbmnAuSebO75zk1MHnHWopg67z1msnuCtjpWpbl",
                                      "mts.cn-north-1.myhuaweicloud.com","093bb6b6c4fc460ab90a40d8b821dda3")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = task_model.DeleteStrTaskRequest()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
        req.task_id = 234

        # 通过client对象调用DeleteExtractTask方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个BaseResponse类的实例，与请求对象对应。
        resp = client.DeleteRemuxTask(req)

        # 打印响应
        print("=====DeleteRemuxTask resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

def retryRemuxTask():
    """retryRemuxTask 重试转封装任务调用SDK实例

    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("3CV7HEQKJYO2HUSWPBGD","BZbmnAuSebO75zk1MHnHWopg67z1msnuCtjpWpbl",
                                      "mts.cn-north-1.myhuaweicloud.com","093bb6b6c4fc460ab90a40d8b821dda3")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = task_model.DeleteStrTaskRequest()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
        req.task_id = 234

        # 通过client对象调用DeleteExtractTask方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个BaseResponse类的实例，与请求对象对应。
        resp = client.RetryRemuxTask(req)

        # 打印响应
        print("=====retryRemuxTask resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

def createAnimatedGraphicsTask():
    """createAnimatedGraphicsTask 创建转动图任务调用SDK实例

    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("3CV7HEQKJYO2HUSWPBGD","BZbmnAuSebO75zk1MHnHWopg67z1msnuCtjpWpbl",
                                      "mts.cn-north-1.myhuaweicloud.com","093bb6b6c4fc460ab90a40d8b821dda3")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = task_model.CreateAnimatedGraphicsTaskReq()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
        params = '''{
                      "input": {
                           "bucket": "lihaiou-02",
                           "location": "cn-north-1",
                           "object": "1_H.264_128X72_HEAACV1_401.mp4"
                      },
                      "output": {
                           "bucket": "lihaiou-02",
                           "location": "cn-north-1",
                           "object": "test/"
                      },
                     "output_param": {
                         "format": "gif",
                         "width": 480,
                         "start": 0,
                         "end": 10,
                         "frame_rate": 15,
                         "height": 270
                     }
                  } '''

        req.from_json_string(params)

        # 通过client对象调用CreateExtractTask方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个CreateTaskResponse类的实例，与请求对象对应。
        resp = client.CreateAnimatedGraphicsTask(req)

        # 打印响应
        print("=====CreateAnimatedGraphicsTask resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

def queryAnimatedGraphicsTask():
    """queryAnimatedGraphicsTask 查询转动图任务调用SDK实例
    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("3CV7HEQKJYO2HUSWPBGD","BZbmnAuSebO75zk1MHnHWopg67z1msnuCtjpWpbl",
                                      "mts.cn-north-1.myhuaweicloud.com","093bb6b6c4fc460ab90a40d8b821dda3")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = task_model.QueryTaskRequest()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
        req.task_id = [1, 300, 607]

        # 通过client对象调用QueryExtractTask方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个QueryTaskResponse类的实例，与请求对象对应。
        resp = client.QueryAnimatedGraphicsTask(req)

        # 打印响应
        print("=====queryAnimatedGraphicsTask resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

def deleteAnimatedGraphicsTask():
    """deleteAnimatedGraphicsTask 删除转动图任务调用SDK实例

    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("3CV7HEQKJYO2HUSWPBGD","BZbmnAuSebO75zk1MHnHWopg67z1msnuCtjpWpbl",
                                      "mts.cn-north-1.myhuaweicloud.com","093bb6b6c4fc460ab90a40d8b821dda3")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = task_model.DeleteStrTaskRequest()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
        req.task_id = 234

        # 通过client对象调用DeleteExtractTask方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个BaseResponse类的实例，与请求对象对应。
        resp = client.DeleteAnimatedGraphicsTask(req)

        # 打印响应
        print("=====deleteAnimatedGraphicsTask resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

def createEncryptTask():
    """createEncryptTask 创建独立加密任务调用SDK实例

    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("3CV7HEQKJYO2HUSWPBGD","BZbmnAuSebO75zk1MHnHWopg67z1msnuCtjpWpbl",
                                      "mts.cn-north-1.myhuaweicloud.com","093bb6b6c4fc460ab90a40d8b821dda3")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = task_model.CreateEncryptRequest()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
        params = '''{
                      "input": {
                           "bucket": "lihaiou-02",
                           "location": "cn-north-1",
                           "object": "1_H.264_128X72_HEAACV1_401.mp4"
                      },
                      "output": {
                           "bucket": "lihaiou-02",
                           "location": "cn-north-1",
                           "object": "test/"
                      },
                     "encryption": {
                             "hls_encrypt": {
                                 "iv": "kadGyMP9MbMkB1IfIKCNaA==",
                                 "key": "NqdGyMP9MbMiB1IfIKCNeQ==",
                                 "url": "xxxxxxx",
                                 "algorithm": "AES-128-CBC"
                             },
                             "preview_duration": 2,
                             "multidrm": {
                                 "emi": 16420,
                                 "content_id": "L6yn9F",
                                 "streaming_mode": "HLS",
                                 "drm_list": [
                                     "PLAYREADY"
                                 ],
                                 "encrypt_audio": 0
                             }
                         }
                  } '''

        req.from_json_string(params)

        # 通过client对象调用CreateExtractTask方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个CreateTaskResponse类的实例，与请求对象对应。
        resp = client.CreateExtractTask(req)

        # 打印响应
        print("=====createEncryptTask resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

def queryEncryptTask():
    """queryEncryptTask 查询加密任务调用SDK实例
    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("3CV7HEQKJYO2HUSWPBGD","BZbmnAuSebO75zk1MHnHWopg67z1msnuCtjpWpbl",
                                      "mts.cn-north-1.myhuaweicloud.com","093bb6b6c4fc460ab90a40d8b821dda3")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = task_model.QueryTaskRequest()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
        req.task_id = [1, 300, 607]

        # 通过client对象调用QueryExtractTask方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个QueryTaskResponse类的实例，与请求对象对应。
        resp = client.QueryEncryptTask(req)

        # 打印响应
        print("=====queryEncryptTask resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

def deleteEncryptTask():
    """deleteEncryptTask 删除加密任务调用SDK实例

    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("3CV7HEQKJYO2HUSWPBGD","BZbmnAuSebO75zk1MHnHWopg67z1msnuCtjpWpbl",
                                      "mts.cn-north-1.myhuaweicloud.com","093bb6b6c4fc460ab90a40d8b821dda3")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = task_model.DeleteStrTaskRequest()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
        req.task_id = 234

        # 通过client对象调用DeleteExtractTask方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个BaseResponse类的实例，与请求对象对应。
        resp = client.DeleteEncryptTask(req)

        # 打印响应
        print("=====deleteEncryptTask resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

def createExtractTask():
    """createExtractTask 创建解析任务调用SDK实例

    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("3CV7HEQKJYO2HUSWPBGD","BZbmnAuSebO75zk1MHnHWopg67z1msnuCtjpWpbl",
                                      "mts.cn-north-1.myhuaweicloud.com","093bb6b6c4fc460ab90a40d8b821dda3")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = task_model.CreateExtractTaskRequest()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
        params = '''{
                      "input": {
                           "bucket": "lihaiou-02",
                           "location": "cn-north-1",
                           "object": "1_H.264_128X72_HEAACV1_401.mp4"
                      },
                      "output": {
                           "bucket": "lihaiou-02",
                           "location": "cn-north-1",
                           "object": "test/"
                      },
                     "sync": 1
                  } '''

        req.from_json_string(params)

        # 通过client对象调用CreateExtractTask方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个CreateTaskResponse类的实例，与请求对象对应。
        resp = client.CreateExtractTask(req)

        # 打印响应
        print("=====CreateExtractTask resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

def queryExtractTask():
    """queryExtractTask 查询解析任务调用SDK实例
    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("3CV7HEQKJYO2HUSWPBGD","BZbmnAuSebO75zk1MHnHWopg67z1msnuCtjpWpbl",
                                      "mts.cn-north-1.myhuaweicloud.com","093bb6b6c4fc460ab90a40d8b821dda3")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = task_model.QueryTaskRequest()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
        req.task_id = [1, 300, 607]

        # 通过client对象调用QueryExtractTask方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个QueryTaskResponse类的实例，与请求对象对应。
        resp = client.QueryExtractTask(req)

        # 打印响应
        print("=====QueryExtractTask resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

def deleteExtractTask():
    """deleteExtractTask 删除视频解析任务调用SDK实例

    """
    try:
        # 实例化要请求产品mpc的client对象
        client = mpc_client.MPCClient("3CV7HEQKJYO2HUSWPBGD","BZbmnAuSebO75zk1MHnHWopg67z1msnuCtjpWpbl",
                                      "mts.cn-north-1.myhuaweicloud.com","093bb6b6c4fc460ab90a40d8b821dda3")

        # 实例化一个mpc实例信息请求对象,每个接口都会对应一个request对象。
        req = task_model.DeleteStrTaskRequest()

        # 这里支持以标准json格式的string来赋值请求参数的方式，也支持request对象输入的方式。
        req.task_id = 234

        # 通过client对象调用DeleteExtractTask方法发起请求。注意请求方法名与请求对象是对应的。
        # 返回的resp是一个BaseResponse类的实例，与请求对象对应。
        resp = client.DeleteExtractTask(req)

        # 打印响应
        print("=====DeleteExtractTask resp")
        print(resp._serialize())

    except MPCSDKException as e:
        print(e)

if __name__ == '__main__':
  # createTrancodeTemplate()
    #queryOneTrancodeTemplate()

    print("python sdk start")

    createTrancodeTask()
    #createTrancodeTask()
    #createWatermarkTemplate()

    #queryTrancodeDetailTask()

    #createTranscodeTaskByBatch()
    #deleteTrancodeTask()

