text: # -*- coding: utf8 -*-
  # Copyright (c) 2017-2021 THL A29 Limited, a Tencent company. All Rights Reserved.
  #
  # Licensed under the Apache License, Version 2.0 (the "License");
  # you may not use this file except in compliance with the License.
  # You may obtain a copy of the License at
  #
  #    http://www.apache.org/licenses/LICENSE-2.0
  #
  # Unless required by applicable law or agreed to in writing, software
  # distributed under the License is distributed on an "AS IS" BASIS,
  # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  # See the License for the specific language governing permissions and
  # limitations under the License.
  
  import json
  
  from tencentcloud.common.exception.tencent_cloud_sdk_exception import TencentCloudSDKException
  from tencentcloud.common.abstract_client import AbstractClient
  from tencentcloud.live.v20180801 import models
  
  
  class LiveClient(AbstractClient):
      _apiVersion = '2018-08-01'
      _endpoint = 'live.tencentcloudapi.com'
      _service = 'live'
  
  
      def AddDelayLiveStream(self, request):
          """针对大型活动直播，通过对直播流设置延时来控制现场与观众播放画面的时间间隔，避免突发状况造成影响。
  
          注意：如果在推流前设置延播，需要提前5分钟设置，目前该接口只支持流粒度。
  
          :param request: Request instance for AddDelayLiveStream.
          :type request: :class:`tencentcloud.live.v20180801.models.AddDelayLiveStreamRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.AddDelayLiveStreamResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("AddDelayLiveStream", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.AddDelayLiveStreamResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def AddLiveDomain(self, request):
          """添加域名，一次只能提交一个域名。域名必须已备案。
  
          :param request: Request instance for AddLiveDomain.
          :type request: :class:`tencentcloud.live.v20180801.models.AddLiveDomainRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.AddLiveDomainResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("AddLiveDomain", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.AddLiveDomainResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def AddLiveWatermark(self, request):
          """添加水印，成功返回水印 ID 后，需要调用[CreateLiveWatermarkRule](/document/product/267/32629)接口将水印 ID 绑定到流使用。
          水印数量上限 100，超过后需要先删除，再添加。
  
          :param request: Request instance for AddLiveWatermark.
          :type request: :class:`tencentcloud.live.v20180801.models.AddLiveWatermarkRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.AddLiveWatermarkResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("AddLiveWatermark", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.AddLiveWatermarkResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def BindLiveDomainCert(self, request):
          """域名绑定证书。
          注意：需先调用添加证书接口进行证书添加。获取到证书Id后再调用该接口进行绑定。
  
          :param request: Request instance for BindLiveDomainCert.
          :type request: :class:`tencentcloud.live.v20180801.models.BindLiveDomainCertRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.BindLiveDomainCertResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("BindLiveDomainCert", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.BindLiveDomainCertResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def CancelCommonMixStream(self, request):
          """该接口用来取消混流。用法与 mix_streamv2.cancel_mix_stream 基本一致。
  
          :param request: Request instance for CancelCommonMixStream.
          :type request: :class:`tencentcloud.live.v20180801.models.CancelCommonMixStreamRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.CancelCommonMixStreamResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("CancelCommonMixStream", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.CancelCommonMixStreamResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def CreateCommonMixStream(self, request):
          """该接口用来创建通用混流。用法与旧接口 mix_streamv2.start_mix_stream_advanced 基本一致。
          注意：当前最多支持16路混流。
          最佳实践：https://cloud.tencent.com/document/product/267/45566
  
          :param request: Request instance for CreateCommonMixStream.
          :type request: :class:`tencentcloud.live.v20180801.models.CreateCommonMixStreamRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.CreateCommonMixStreamResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("CreateCommonMixStream", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.CreateCommonMixStreamResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def CreateLiveCallbackRule(self, request):
          """创建回调规则，需要先调用[CreateLiveCallbackTemplate](/document/product/267/32637)接口创建回调模板，将返回的模板id绑定到域名/路径进行使用。
          <br>回调协议相关文档：[事件消息通知](/document/product/267/32744)。
  
          :param request: Request instance for CreateLiveCallbackRule.
          :type request: :class:`tencentcloud.live.v20180801.models.CreateLiveCallbackRuleRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.CreateLiveCallbackRuleResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("CreateLiveCallbackRule", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.CreateLiveCallbackRuleResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def CreateLiveCallbackTemplate(self, request):
          """创建回调模板，成功返回模板id后，需要调用[CreateLiveCallbackRule](/document/product/267/32638)接口将模板 ID 绑定到域名/路径使用。
          <br>回调协议相关文档：[事件消息通知](/document/product/267/32744)。
          注意：至少填写一个回调 URL。
  
          :param request: Request instance for CreateLiveCallbackTemplate.
          :type request: :class:`tencentcloud.live.v20180801.models.CreateLiveCallbackTemplateRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.CreateLiveCallbackTemplateResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("CreateLiveCallbackTemplate", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.CreateLiveCallbackTemplateResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def CreateLiveCert(self, request):
          """添加证书
  
          :param request: Request instance for CreateLiveCert.
          :type request: :class:`tencentcloud.live.v20180801.models.CreateLiveCertRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.CreateLiveCertResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("CreateLiveCert", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.CreateLiveCertResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def CreateLivePullStreamTask(self, request):
          """创建直播拉流任务。支持将外部已有的点播文件，或者直播源拉取过来转推到直播系统。
          注意：
          1. 默认支持任务数上限20个，如有特殊需求，可通过提单到售后进行评估增加上限。
          2. 目前仅支持推流到腾讯云直播，暂不支持推到第三方。
          3. 源流视频编码目前只支持: H264, H265。其他编码格式建议先进行转码处理。
          4. 源流音频编码目前只支持: AAC。其他编码格式建议先进行转码处理。
          5. 过期不用的任务需自行清理，未清理的过期任务也会占用上限额度，如需要自动清理过期任务，可提单给售后进行配置。
          6. 拉流转推功能为计费增值服务，计费规则详情可参见[计费文档](https://cloud.tencent.com/document/product/267/53308)。
          7. 拉流转推功能仅提供内容拉取与推送服务，请确保内容已获得授权并符合内容传播相关的法律法规。若内容有侵权或违规相关问题，云直播会停止相关的功能服务并保留追究法律责任的权利。
  
          :param request: Request instance for CreateLivePullStreamTask.
          :type request: :class:`tencentcloud.live.v20180801.models.CreateLivePullStreamTaskRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.CreateLivePullStreamTaskResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("CreateLivePullStreamTask", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.CreateLivePullStreamTaskResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def CreateLiveRecord(self, request):
          """- 使用前提
            1. 录制文件存放于点播平台，所以用户如需使用录制功能，需首先自行开通点播服务。
            2. 录制文件存放后相关费用（含存储以及下行播放流量）按照点播平台计费方式收取，具体请参考 [对应文档](https://cloud.tencent.com/document/product/266/2838)。
  
          - 模式说明
            该接口支持两种录制模式：
            1. 定时录制模式【默认模式】。
              需要传入开始时间与结束时间，录制任务根据起止时间自动开始与结束。在所设置结束时间过期之前（且未调用StopLiveRecord提前终止任务），录制任务都是有效的，期间多次断流然后重推都会启动录制任务。
            2. 实时视频录制模式。
              忽略传入的开始时间，在录制任务创建后立即开始录制，录制时长支持最大为30分钟，如果传入的结束时间与当前时间差大于30分钟，则按30分钟计算，实时视频录制主要用于录制精彩视频场景，时长建议控制在5分钟以内。
  
          - 注意事项
            1. 调用接口超时设置应大于3秒，小于3秒重试以及按不同起止时间调用都有可能产生重复录制任务，进而导致额外录制费用。
            2. 受限于音视频文件格式（FLV/MP4/HLS）对编码类型的支持，视频编码类型支持 H.264，音频编码类型支持 AAC。
            3. 为避免恶意或非主观的频繁 API 请求，对定时录制模式最大创建任务数做了限制：其中，当天可以创建的最大任务数不超过4000（不含已删除的任务）；当前时刻并发运行的任务数不超过400。有超出此限制的需要提工单申请。
            4. 此调用方式暂时不支持海外推流录制。
  
          :param request: Request instance for CreateLiveRecord.
          :type request: :class:`tencentcloud.live.v20180801.models.CreateLiveRecordRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.CreateLiveRecordResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("CreateLiveRecord", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.CreateLiveRecordResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def CreateLiveRecordRule(self, request):
          """创建录制规则，需要先调用[CreateLiveRecordTemplate](/document/product/267/32614)接口创建录制模板，将返回的模板id绑定到流使用。
          <br>录制相关文档：[直播录制](/document/product/267/32739)。
  
          :param request: Request instance for CreateLiveRecordRule.
          :type request: :class:`tencentcloud.live.v20180801.models.CreateLiveRecordRuleRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.CreateLiveRecordRuleResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("CreateLiveRecordRule", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.CreateLiveRecordRuleResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def CreateLiveRecordTemplate(self, request):
          """创建录制模板，成功返回模板id后，需要调用[CreateLiveRecordRule](/document/product/267/32615)接口，将模板id绑定到流进行使用。
          <br>录制相关文档：[直播录制](/document/product/267/32739)。
  
          :param request: Request instance for CreateLiveRecordTemplate.
          :type request: :class:`tencentcloud.live.v20180801.models.CreateLiveRecordTemplateRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.CreateLiveRecordTemplateResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("CreateLiveRecordTemplate", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.CreateLiveRecordTemplateResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def CreateLiveSnapshotRule(self, request):
          """创建截图规则，需要先调用[CreateLiveSnapshotTemplate](/document/product/267/32624)接口创建截图模板，然后将返回的模板 ID 绑定到流进行使用。
          <br>截图相关文档：[直播截图](/document/product/267/32737)。
          注意：单个域名仅支持关联一个截图模板。
  
          :param request: Request instance for CreateLiveSnapshotRule.
          :type request: :class:`tencentcloud.live.v20180801.models.CreateLiveSnapshotRuleRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.CreateLiveSnapshotRuleResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("CreateLiveSnapshotRule", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.CreateLiveSnapshotRuleResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def CreateLiveSnapshotTemplate(self, request):
          """创建截图模板，成功返回模板id后，需要调用[CreateLiveSnapshotRule](/document/product/267/32625)接口，将模板id绑定到流使用。
          <br>截图相关文档：[直播截图](/document/product/267/32737)。
  
          :param request: Request instance for CreateLiveSnapshotTemplate.
          :type request: :class:`tencentcloud.live.v20180801.models.CreateLiveSnapshotTemplateRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.CreateLiveSnapshotTemplateResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("CreateLiveSnapshotTemplate", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.CreateLiveSnapshotTemplateResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def CreateLiveTranscodeRule(self, request):
          """创建转码规则，需要先调用[CreateLiveTranscodeTemplate](/document/product/267/32646)接口创建转码模板，将返回的模板id绑定到流使用。
          <br>转码相关文档：[直播转封装及转码](/document/product/267/32736)。
  
          :param request: Request instance for CreateLiveTranscodeRule.
          :type request: :class:`tencentcloud.live.v20180801.models.CreateLiveTranscodeRuleRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.CreateLiveTranscodeRuleResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("CreateLiveTranscodeRule", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.CreateLiveTranscodeRuleResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def CreateLiveTranscodeTemplate(self, request):
          """创建转码模板，成功返回模板id后，需要调用[CreateLiveTranscodeRule](/document/product/267/32647)接口，将返回的模板id绑定到流使用。
          <br>转码相关文档：[直播转封装及转码](/document/product/267/32736)。
  
          :param request: Request instance for CreateLiveTranscodeTemplate.
          :type request: :class:`tencentcloud.live.v20180801.models.CreateLiveTranscodeTemplateRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.CreateLiveTranscodeTemplateResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("CreateLiveTranscodeTemplate", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.CreateLiveTranscodeTemplateResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def CreateLiveWatermarkRule(self, request):
          """创建水印规则，需要先调用[AddLiveWatermark](/document/product/267/30154)接口添加水印，将返回的水印id绑定到流使用。
  
          :param request: Request instance for CreateLiveWatermarkRule.
          :type request: :class:`tencentcloud.live.v20180801.models.CreateLiveWatermarkRuleRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.CreateLiveWatermarkRuleResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("CreateLiveWatermarkRule", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.CreateLiveWatermarkRuleResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def CreatePullStreamConfig(self, request):
          """创建临时拉流转推任务，目前限制添加10条任务。
  
          注意：该接口用于创建临时拉流转推任务，
          拉流源地址即 FromUrl 可以是腾讯或非腾讯数据源，
          但转推目标地址即 ToUrl 目前限制为已注册的腾讯直播域名。
  
          :param request: Request instance for CreatePullStreamConfig.
          :type request: :class:`tencentcloud.live.v20180801.models.CreatePullStreamConfigRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.CreatePullStreamConfigResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("CreatePullStreamConfig", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.CreatePullStreamConfigResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def CreateRecordTask(self, request):
          """创建一个在指定时间启动、结束的录制任务，并使用指定录制模板ID对应的配置进行录制。
          - 使用前提
          1. 录制文件存放于点播平台，所以用户如需使用录制功能，需首先自行开通点播服务。
          2. 录制文件存放后相关费用（含存储以及下行播放流量）按照点播平台计费方式收取，具体请参考 [对应文档](https://cloud.tencent.com/document/product/266/2837)。
          - 注意事项
          1. 断流会结束当前录制并生成录制文件。在结束时间到达之前任务仍然有效，期间只要正常推流都会正常录制，与是否多次推、断流无关。
          2. 使用上避免创建时间段相互重叠的录制任务。若同一条流当前存在多个时段重叠的任务，为避免重复录制系统将启动最多3个录制任务。
          3. 创建的录制任务记录在平台侧只保留3个月。
          4. 当前录制任务管理API（CreateRecordTask/StopRecordTask/DeleteRecordTask）与旧API（CreateLiveRecord/StopLiveRecord/DeleteLiveRecord）不兼容，两套接口不能混用。
          5. 避免 创建录制任务 与 推流 操作同时进行，可能导致因录制任务未生效而引起任务延迟启动问题，两者操作间隔建议大于3秒。
  
          :param request: Request instance for CreateRecordTask.
          :type request: :class:`tencentcloud.live.v20180801.models.CreateRecordTaskRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.CreateRecordTaskResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("CreateRecordTask", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.CreateRecordTaskResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DeleteLiveCallbackRule(self, request):
          """删除回调规则。
  
          :param request: Request instance for DeleteLiveCallbackRule.
          :type request: :class:`tencentcloud.live.v20180801.models.DeleteLiveCallbackRuleRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DeleteLiveCallbackRuleResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DeleteLiveCallbackRule", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DeleteLiveCallbackRuleResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DeleteLiveCallbackTemplate(self, request):
          """删除回调模板。
  
          :param request: Request instance for DeleteLiveCallbackTemplate.
          :type request: :class:`tencentcloud.live.v20180801.models.DeleteLiveCallbackTemplateRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DeleteLiveCallbackTemplateResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DeleteLiveCallbackTemplate", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DeleteLiveCallbackTemplateResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DeleteLiveCert(self, request):
          """删除域名对应的证书
  
          :param request: Request instance for DeleteLiveCert.
          :type request: :class:`tencentcloud.live.v20180801.models.DeleteLiveCertRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DeleteLiveCertResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DeleteLiveCert", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DeleteLiveCertResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DeleteLiveDomain(self, request):
          """删除已添加的直播域名
  
          :param request: Request instance for DeleteLiveDomain.
          :type request: :class:`tencentcloud.live.v20180801.models.DeleteLiveDomainRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DeleteLiveDomainResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DeleteLiveDomain", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DeleteLiveDomainResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DeleteLivePullStreamTask(self, request):
          """删除接口 CreateLivePullStreamTask 创建的拉流任务。
          注意：
          1. 入参中的 TaskId 为 CreateLivePullStreamTask 接口创建时返回的TaskId。
          2. 也可通过 DescribeLivePullStreamTasks 进行查询创建的任务。
  
          :param request: Request instance for DeleteLivePullStreamTask.
          :type request: :class:`tencentcloud.live.v20180801.models.DeleteLivePullStreamTaskRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DeleteLivePullStreamTaskResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DeleteLivePullStreamTask", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DeleteLivePullStreamTaskResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DeleteLiveRecord(self, request):
          """注：DeleteLiveRecord 接口仅用于删除录制任务记录，不具备停止录制的功能，也不能删除正在进行中的录制。如果需要停止录制任务，请使用终止录制[StopLiveRecord](/document/product/267/30146) 接口。
  
          :param request: Request instance for DeleteLiveRecord.
          :type request: :class:`tencentcloud.live.v20180801.models.DeleteLiveRecordRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DeleteLiveRecordResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DeleteLiveRecord", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DeleteLiveRecordResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DeleteLiveRecordRule(self, request):
          """删除录制规则。
  
          :param request: Request instance for DeleteLiveRecordRule.
          :type request: :class:`tencentcloud.live.v20180801.models.DeleteLiveRecordRuleRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DeleteLiveRecordRuleResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DeleteLiveRecordRule", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DeleteLiveRecordRuleResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DeleteLiveRecordTemplate(self, request):
          """删除录制模板。
  
          :param request: Request instance for DeleteLiveRecordTemplate.
          :type request: :class:`tencentcloud.live.v20180801.models.DeleteLiveRecordTemplateRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DeleteLiveRecordTemplateResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DeleteLiveRecordTemplate", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DeleteLiveRecordTemplateResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DeleteLiveSnapshotRule(self, request):
          """删除截图规则。
  
          :param request: Request instance for DeleteLiveSnapshotRule.
          :type request: :class:`tencentcloud.live.v20180801.models.DeleteLiveSnapshotRuleRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DeleteLiveSnapshotRuleResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DeleteLiveSnapshotRule", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DeleteLiveSnapshotRuleResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DeleteLiveSnapshotTemplate(self, request):
          """删除截图模板
  
          :param request: Request instance for DeleteLiveSnapshotTemplate.
          :type request: :class:`tencentcloud.live.v20180801.models.DeleteLiveSnapshotTemplateRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DeleteLiveSnapshotTemplateResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DeleteLiveSnapshotTemplate", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DeleteLiveSnapshotTemplateResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DeleteLiveTranscodeRule(self, request):
          """删除转码规则。
          DomainName+AppName+StreamName+TemplateId唯一标识单个转码规则，如需删除需要强匹配。其中TemplateId必填，其余参数为空时也需要传空字符串进行强匹配。
  
          :param request: Request instance for DeleteLiveTranscodeRule.
          :type request: :class:`tencentcloud.live.v20180801.models.DeleteLiveTranscodeRuleRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DeleteLiveTranscodeRuleResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DeleteLiveTranscodeRule", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DeleteLiveTranscodeRuleResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DeleteLiveTranscodeTemplate(self, request):
          """删除转码模板。
  
          :param request: Request instance for DeleteLiveTranscodeTemplate.
          :type request: :class:`tencentcloud.live.v20180801.models.DeleteLiveTranscodeTemplateRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DeleteLiveTranscodeTemplateResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DeleteLiveTranscodeTemplate", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DeleteLiveTranscodeTemplateResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DeleteLiveWatermark(self, request):
          """删除水印。
  
          :param request: Request instance for DeleteLiveWatermark.
          :type request: :class:`tencentcloud.live.v20180801.models.DeleteLiveWatermarkRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DeleteLiveWatermarkResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DeleteLiveWatermark", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DeleteLiveWatermarkResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DeleteLiveWatermarkRule(self, request):
          """删除水印规则
  
          :param request: Request instance for DeleteLiveWatermarkRule.
          :type request: :class:`tencentcloud.live.v20180801.models.DeleteLiveWatermarkRuleRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DeleteLiveWatermarkRuleResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DeleteLiveWatermarkRule", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DeleteLiveWatermarkRuleResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DeletePullStreamConfig(self, request):
          """删除直播拉流配置。
  
          :param request: Request instance for DeletePullStreamConfig.
          :type request: :class:`tencentcloud.live.v20180801.models.DeletePullStreamConfigRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DeletePullStreamConfigResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DeletePullStreamConfig", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DeletePullStreamConfigResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DeleteRecordTask(self, request):
          """删除录制任务配置。删除操作不影响正在运行当中的任务，仅对删除之后新的推流有效。
  
          :param request: Request instance for DeleteRecordTask.
          :type request: :class:`tencentcloud.live.v20180801.models.DeleteRecordTaskRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DeleteRecordTaskResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DeleteRecordTask", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DeleteRecordTaskResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeAllStreamPlayInfoList(self, request):
          """输入某个时间点（1分钟维度），查询该时间点所有流的下行信息。
  
          :param request: Request instance for DescribeAllStreamPlayInfoList.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeAllStreamPlayInfoListRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeAllStreamPlayInfoListResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeAllStreamPlayInfoList", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeAllStreamPlayInfoListResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeAreaBillBandwidthAndFluxList(self, request):
          """海外分区直播计费带宽和流量数据查询。
  
          :param request: Request instance for DescribeAreaBillBandwidthAndFluxList.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeAreaBillBandwidthAndFluxListRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeAreaBillBandwidthAndFluxListResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeAreaBillBandwidthAndFluxList", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeAreaBillBandwidthAndFluxListResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeBillBandwidthAndFluxList(self, request):
          """直播计费带宽和流量数据查询。
  
          :param request: Request instance for DescribeBillBandwidthAndFluxList.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeBillBandwidthAndFluxListRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeBillBandwidthAndFluxListResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeBillBandwidthAndFluxList", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeBillBandwidthAndFluxListResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeCallbackRecordsList(self, request):
          """用于查询回调事件。
  
          :param request: Request instance for DescribeCallbackRecordsList.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeCallbackRecordsListRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeCallbackRecordsListResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeCallbackRecordsList", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeCallbackRecordsListResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeConcurrentRecordStreamNum(self, request):
          """查询并发录制路数，对慢直播和普通直播适用。
  
          :param request: Request instance for DescribeConcurrentRecordStreamNum.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeConcurrentRecordStreamNumRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeConcurrentRecordStreamNumResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeConcurrentRecordStreamNum", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeConcurrentRecordStreamNumResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeDeliverBandwidthList(self, request):
          """查询直播转推计费带宽，查询时间范围最大支持3个月内的数据，时间跨度最长31天。
  
          :param request: Request instance for DescribeDeliverBandwidthList.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeDeliverBandwidthListRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeDeliverBandwidthListResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeDeliverBandwidthList", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeDeliverBandwidthListResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeGroupProIspPlayInfoList(self, request):
          """查询按省份和运营商分组的下行播放数据。
  
          :param request: Request instance for DescribeGroupProIspPlayInfoList.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeGroupProIspPlayInfoListRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeGroupProIspPlayInfoListResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeGroupProIspPlayInfoList", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeGroupProIspPlayInfoListResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeHttpStatusInfoList(self, request):
          """查询某段时间内5分钟粒度的各播放http状态码的个数。
          备注：数据延迟1小时，如10:00-10:59点的数据12点才能查到。
  
          :param request: Request instance for DescribeHttpStatusInfoList.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeHttpStatusInfoListRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeHttpStatusInfoListResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeHttpStatusInfoList", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeHttpStatusInfoListResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLiveCallbackRules(self, request):
          """获取回调规则列表
  
          :param request: Request instance for DescribeLiveCallbackRules.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLiveCallbackRulesRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLiveCallbackRulesResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLiveCallbackRules", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLiveCallbackRulesResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLiveCallbackTemplate(self, request):
          """获取单个回调模板。
  
          :param request: Request instance for DescribeLiveCallbackTemplate.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLiveCallbackTemplateRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLiveCallbackTemplateResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLiveCallbackTemplate", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLiveCallbackTemplateResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLiveCallbackTemplates(self, request):
          """获取回调模板列表
  
          :param request: Request instance for DescribeLiveCallbackTemplates.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLiveCallbackTemplatesRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLiveCallbackTemplatesResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLiveCallbackTemplates", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLiveCallbackTemplatesResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLiveCert(self, request):
          """获取证书信息
  
          :param request: Request instance for DescribeLiveCert.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLiveCertRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLiveCertResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLiveCert", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLiveCertResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLiveCerts(self, request):
          """获取证书信息列表
  
          :param request: Request instance for DescribeLiveCerts.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLiveCertsRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLiveCertsResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLiveCerts", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLiveCertsResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLiveDelayInfoList(self, request):
          """获取直播延播列表。
  
          :param request: Request instance for DescribeLiveDelayInfoList.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLiveDelayInfoListRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLiveDelayInfoListResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLiveDelayInfoList", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLiveDelayInfoListResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLiveDomain(self, request):
          """查询直播域名信息。
  
          :param request: Request instance for DescribeLiveDomain.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLiveDomainRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLiveDomainResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLiveDomain", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLiveDomainResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLiveDomainCert(self, request):
          """获取域名证书信息。
  
          :param request: Request instance for DescribeLiveDomainCert.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLiveDomainCertRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLiveDomainCertResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLiveDomainCert", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLiveDomainCertResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLiveDomainPlayInfoList(self, request):
          """查询实时的域名维度下行播放数据，由于数据处理有耗时，接口默认查询4分钟前的准实时数据。
  
          :param request: Request instance for DescribeLiveDomainPlayInfoList.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLiveDomainPlayInfoListRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLiveDomainPlayInfoListResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLiveDomainPlayInfoList", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLiveDomainPlayInfoListResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLiveDomainReferer(self, request):
          """查询直播域名 Referer 黑白名单配置。
          由于 Referer 信息包含在 http 协议中，在开启配置后，播放协议为 rtmp 或 WebRTC 不会校验 Referer 配置，仍可正常播放。如需配置 Referer 鉴权建议使用 http-flv 或 http-hls 协议播放。
  
          :param request: Request instance for DescribeLiveDomainReferer.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLiveDomainRefererRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLiveDomainRefererResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLiveDomainReferer", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLiveDomainRefererResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLiveDomains(self, request):
          """根据域名状态、类型等信息查询用户的域名信息。
  
          :param request: Request instance for DescribeLiveDomains.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLiveDomainsRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLiveDomainsResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLiveDomains", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLiveDomainsResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLiveForbidStreamList(self, request):
          """获取禁推流列表。
  
          注意：该接口仅作为直播辅助查询接口，重要业务场景不可强依赖该接口。
  
          :param request: Request instance for DescribeLiveForbidStreamList.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLiveForbidStreamListRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLiveForbidStreamListResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLiveForbidStreamList", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLiveForbidStreamListResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLivePackageInfo(self, request):
          """查询用户套餐包总量、使用量、剩余量、包状态、购买时间和过期时间等。
  
          :param request: Request instance for DescribeLivePackageInfo.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLivePackageInfoRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLivePackageInfoResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLivePackageInfo", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLivePackageInfoResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLivePlayAuthKey(self, request):
          """查询播放鉴权key。
  
          :param request: Request instance for DescribeLivePlayAuthKey.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLivePlayAuthKeyRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLivePlayAuthKeyResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLivePlayAuthKey", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLivePlayAuthKeyResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLivePullStreamTasks(self, request):
          """查询使用 CreateLivePullStreamTask 接口创建的直播拉流任务。
          排序方式：默认按更新时间 倒序排列。
  
          :param request: Request instance for DescribeLivePullStreamTasks.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLivePullStreamTasksRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLivePullStreamTasksResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLivePullStreamTasks", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLivePullStreamTasksResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLivePushAuthKey(self, request):
          """查询直播推流鉴权key
  
          :param request: Request instance for DescribeLivePushAuthKey.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLivePushAuthKeyRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLivePushAuthKeyResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLivePushAuthKey", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLivePushAuthKeyResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLiveRecordRules(self, request):
          """获取录制规则列表
  
          :param request: Request instance for DescribeLiveRecordRules.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLiveRecordRulesRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLiveRecordRulesResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLiveRecordRules", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLiveRecordRulesResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLiveRecordTemplate(self, request):
          """获取单个录制模板。
  
          :param request: Request instance for DescribeLiveRecordTemplate.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLiveRecordTemplateRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLiveRecordTemplateResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLiveRecordTemplate", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLiveRecordTemplateResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLiveRecordTemplates(self, request):
          """获取录制模板列表。
  
          :param request: Request instance for DescribeLiveRecordTemplates.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLiveRecordTemplatesRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLiveRecordTemplatesResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLiveRecordTemplates", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLiveRecordTemplatesResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLiveSnapshotRules(self, request):
          """获取截图规则列表
  
          :param request: Request instance for DescribeLiveSnapshotRules.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLiveSnapshotRulesRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLiveSnapshotRulesResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLiveSnapshotRules", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLiveSnapshotRulesResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLiveSnapshotTemplate(self, request):
          """获取单个截图模板。
  
          :param request: Request instance for DescribeLiveSnapshotTemplate.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLiveSnapshotTemplateRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLiveSnapshotTemplateResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLiveSnapshotTemplate", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLiveSnapshotTemplateResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLiveSnapshotTemplates(self, request):
          """获取截图模板列表。
  
          :param request: Request instance for DescribeLiveSnapshotTemplates.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLiveSnapshotTemplatesRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLiveSnapshotTemplatesResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLiveSnapshotTemplates", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLiveSnapshotTemplatesResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLiveStreamEventList(self, request):
          """用于查询推断流事件。<br>
  
          注意：
          1. 该接口提供离线推断流记录查询功能，不可作为重要业务场景强依赖接口。
          2. 该接口可通过使用IsFilter进行过滤，返回推流历史记录。
  
          :param request: Request instance for DescribeLiveStreamEventList.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLiveStreamEventListRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLiveStreamEventListResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLiveStreamEventList", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLiveStreamEventListResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLiveStreamOnlineList(self, request):
          """返回正在直播中的流列表。适用于推流成功后查询在线流信息。
  
          注意：
          1. 该接口仅提供辅助查询在线流列表功能，业务重要场景不可强依赖该接口。
          2. 该接口仅适用于流数少于2万路的情况，对于流数较大用户请联系售后。
  
          :param request: Request instance for DescribeLiveStreamOnlineList.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLiveStreamOnlineListRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLiveStreamOnlineListResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLiveStreamOnlineList", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLiveStreamOnlineListResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLiveStreamPublishedList(self, request):
          """返回已经推过流的流列表。<br>
          注意：分页最多支持查询1万条记录，可通过调整查询时间范围来获取更多数据。
  
          :param request: Request instance for DescribeLiveStreamPublishedList.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLiveStreamPublishedListRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLiveStreamPublishedListResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLiveStreamPublishedList", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLiveStreamPublishedListResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLiveStreamPushInfoList(self, request):
          """查询所有实时流的推流信息，包括客户端IP，服务端IP，帧率，码率，域名，开始推流时间。
  
          :param request: Request instance for DescribeLiveStreamPushInfoList.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLiveStreamPushInfoListRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLiveStreamPushInfoListResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLiveStreamPushInfoList", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLiveStreamPushInfoListResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLiveStreamState(self, request):
          """返回直播中、无推流或者禁播等状态。
          注意：该接口仅提供辅助查询流状态功能，业务重要场景不要强依赖该接口！
  
          使用建议：
          1. 去除将该接口的返回结果作为开播、关播等重要业务场景的依赖。
          2. 如业务需要该状态,可通过[推断流事件通知](/document/product/267/47025)进行存储维护直播间状态。
          3. 自行维护的直播间状态,可通过定时(>1 min)[查询直播中的流接口](/document/product/267/20472),进行状态校准。
          4. 如使用了流状态查询接口查询到流不活跃,可通过上述多种方案综合判定流状态。
          5. 接口查询时,如发生访问异常或解析异常等,可默认为活跃,减少对业务影响。
  
          :param request: Request instance for DescribeLiveStreamState.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLiveStreamStateRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLiveStreamStateResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLiveStreamState", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLiveStreamStateResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLiveTranscodeDetailInfo(self, request):
          """支持查询某天或某段时间的转码详细信息。
  
          :param request: Request instance for DescribeLiveTranscodeDetailInfo.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLiveTranscodeDetailInfoRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLiveTranscodeDetailInfoResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLiveTranscodeDetailInfo", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLiveTranscodeDetailInfoResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLiveTranscodeRules(self, request):
          """获取转码规则列表
  
          :param request: Request instance for DescribeLiveTranscodeRules.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLiveTranscodeRulesRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLiveTranscodeRulesResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLiveTranscodeRules", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLiveTranscodeRulesResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLiveTranscodeTemplate(self, request):
          """获取单个转码模板。
  
          :param request: Request instance for DescribeLiveTranscodeTemplate.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLiveTranscodeTemplateRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLiveTranscodeTemplateResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLiveTranscodeTemplate", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLiveTranscodeTemplateResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLiveTranscodeTemplates(self, request):
          """获取转码模板列表。
  
          :param request: Request instance for DescribeLiveTranscodeTemplates.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLiveTranscodeTemplatesRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLiveTranscodeTemplatesResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLiveTranscodeTemplates", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLiveTranscodeTemplatesResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLiveTranscodeTotalInfo(self, request):
          """查询转码总量数据，可查询近30天内数据。
          注意：
          如果是查询某一天内，则返回5分钟粒度数据；
          如果是查询跨天或指定域名， 则返回1小时粒度数据。
  
          :param request: Request instance for DescribeLiveTranscodeTotalInfo.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLiveTranscodeTotalInfoRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLiveTranscodeTotalInfoResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLiveTranscodeTotalInfo", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLiveTranscodeTotalInfoResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLiveWatermark(self, request):
          """获取单个水印信息。
  
          :param request: Request instance for DescribeLiveWatermark.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLiveWatermarkRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLiveWatermarkResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLiveWatermark", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLiveWatermarkResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLiveWatermarkRules(self, request):
          """获取水印规则列表。
  
          :param request: Request instance for DescribeLiveWatermarkRules.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLiveWatermarkRulesRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLiveWatermarkRulesResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLiveWatermarkRules", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLiveWatermarkRulesResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLiveWatermarks(self, request):
          """查询水印列表。
  
          :param request: Request instance for DescribeLiveWatermarks.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLiveWatermarksRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLiveWatermarksResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLiveWatermarks", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLiveWatermarksResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeLogDownloadList(self, request):
          """批量获取日志URL。
  
          :param request: Request instance for DescribeLogDownloadList.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeLogDownloadListRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeLogDownloadListResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeLogDownloadList", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeLogDownloadListResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribePlayErrorCodeDetailInfoList(self, request):
          """查询下行播放错误码信息，某段时间内1分钟粒度的各http错误码出现的次数，包括4xx，5xx。
  
  
          :param request: Request instance for DescribePlayErrorCodeDetailInfoList.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribePlayErrorCodeDetailInfoListRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribePlayErrorCodeDetailInfoListResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribePlayErrorCodeDetailInfoList", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribePlayErrorCodeDetailInfoListResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribePlayErrorCodeSumInfoList(self, request):
          """查询下行播放错误码信息。
  
          :param request: Request instance for DescribePlayErrorCodeSumInfoList.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribePlayErrorCodeSumInfoListRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribePlayErrorCodeSumInfoListResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribePlayErrorCodeSumInfoList", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribePlayErrorCodeSumInfoListResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeProIspPlaySumInfoList(self, request):
          """查询某段时间内每个国家地区每个省份每个运营商的平均每秒流量，总流量，总请求数信息。
  
          :param request: Request instance for DescribeProIspPlaySumInfoList.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeProIspPlaySumInfoListRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeProIspPlaySumInfoListResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeProIspPlaySumInfoList", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeProIspPlaySumInfoListResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeProvinceIspPlayInfoList(self, request):
          """查询某省份某运营商下行播放数据，包括带宽，流量，请求数，并发连接数信息。
  
          :param request: Request instance for DescribeProvinceIspPlayInfoList.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeProvinceIspPlayInfoListRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeProvinceIspPlayInfoListResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeProvinceIspPlayInfoList", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeProvinceIspPlayInfoListResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribePullStreamConfigs(self, request):
          """查询直播拉流配置。
  
          :param request: Request instance for DescribePullStreamConfigs.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribePullStreamConfigsRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribePullStreamConfigsResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribePullStreamConfigs", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribePullStreamConfigsResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribePushBandwidthAndFluxList(self, request):
          """直播推流带宽和流量数据查询。
          推流计费会先取全球推流用量和全球播放用量进行比较，满足计费条件后再按各地区用量出账。详情参见[计费文档](https://cloud.tencent.com/document/product/267/34175)。
  
          :param request: Request instance for DescribePushBandwidthAndFluxList.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribePushBandwidthAndFluxListRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribePushBandwidthAndFluxListResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribePushBandwidthAndFluxList", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribePushBandwidthAndFluxListResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeRecordTask(self, request):
          """查询指定时间段范围内启动和结束的录制任务列表。
          - 使用前提
          1. 仅用于查询由 CreateRecordTask 接口创建的录制任务。
          2. 不能查询被 DeleteRecordTask 接口删除以及已过期（平台侧保留3个月）的录制任务。
  
          :param request: Request instance for DescribeRecordTask.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeRecordTaskRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeRecordTaskResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeRecordTask", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeRecordTaskResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeScreenShotSheetNumList(self, request):
          """接口用来查询直播增值业务--截图的张数
  
          :param request: Request instance for DescribeScreenShotSheetNumList.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeScreenShotSheetNumListRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeScreenShotSheetNumListResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeScreenShotSheetNumList", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeScreenShotSheetNumListResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeStreamDayPlayInfoList(self, request):
          """查询天维度每条流的播放数据，包括总流量等。
  
          :param request: Request instance for DescribeStreamDayPlayInfoList.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeStreamDayPlayInfoListRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeStreamDayPlayInfoListResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeStreamDayPlayInfoList", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeStreamDayPlayInfoListResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeStreamPlayInfoList(self, request):
          """查询播放数据，支持按流名称查询详细播放数据，也可按播放域名查询详细总数据，数据延迟4分钟左右。
          注意：按AppName查询请先联系工单申请，开通后配置生效预计需要5个工作日左右，具体时间以最终回复为准。
  
          :param request: Request instance for DescribeStreamPlayInfoList.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeStreamPlayInfoListRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeStreamPlayInfoListResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeStreamPlayInfoList", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeStreamPlayInfoListResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeStreamPushInfoList(self, request):
          """查询流id的上行推流质量数据，包括音视频的帧率，码率，流逝时间，编码格式等。
  
          :param request: Request instance for DescribeStreamPushInfoList.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeStreamPushInfoListRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeStreamPushInfoListResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeStreamPushInfoList", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeStreamPushInfoListResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeTopClientIpSumInfoList(self, request):
          """查询某段时间top n客户端ip汇总信息（暂支持top 1000）
  
          :param request: Request instance for DescribeTopClientIpSumInfoList.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeTopClientIpSumInfoListRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeTopClientIpSumInfoListResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeTopClientIpSumInfoList", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeTopClientIpSumInfoListResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeUploadStreamNums(self, request):
          """直播上行路数查询
  
          :param request: Request instance for DescribeUploadStreamNums.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeUploadStreamNumsRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeUploadStreamNumsResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeUploadStreamNums", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeUploadStreamNumsResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DescribeVisitTopSumInfoList(self, request):
          """查询某时间段top n的域名或流id信息（暂支持top 1000）。
  
          :param request: Request instance for DescribeVisitTopSumInfoList.
          :type request: :class:`tencentcloud.live.v20180801.models.DescribeVisitTopSumInfoListRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DescribeVisitTopSumInfoListResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DescribeVisitTopSumInfoList", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DescribeVisitTopSumInfoListResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def DropLiveStream(self, request):
          """断开推流连接，但可以重新推流。
  
          :param request: Request instance for DropLiveStream.
          :type request: :class:`tencentcloud.live.v20180801.models.DropLiveStreamRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.DropLiveStreamResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("DropLiveStream", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.DropLiveStreamResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def EnableLiveDomain(self, request):
          """启用状态为停用的直播域名。
  
          :param request: Request instance for EnableLiveDomain.
          :type request: :class:`tencentcloud.live.v20180801.models.EnableLiveDomainRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.EnableLiveDomainResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("EnableLiveDomain", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.EnableLiveDomainResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def ForbidLiveDomain(self, request):
          """停止使用某个直播域名。
  
          :param request: Request instance for ForbidLiveDomain.
          :type request: :class:`tencentcloud.live.v20180801.models.ForbidLiveDomainRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.ForbidLiveDomainResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("ForbidLiveDomain", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.ForbidLiveDomainResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def ForbidLiveStream(self, request):
          """禁止某条流的推送，可以预设某个时刻将流恢复。
  
          :param request: Request instance for ForbidLiveStream.
          :type request: :class:`tencentcloud.live.v20180801.models.ForbidLiveStreamRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.ForbidLiveStreamResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("ForbidLiveStream", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.ForbidLiveStreamResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def ModifyLiveCallbackTemplate(self, request):
          """修改回调模板。
  
          :param request: Request instance for ModifyLiveCallbackTemplate.
          :type request: :class:`tencentcloud.live.v20180801.models.ModifyLiveCallbackTemplateRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.ModifyLiveCallbackTemplateResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("ModifyLiveCallbackTemplate", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.ModifyLiveCallbackTemplateResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def ModifyLiveCert(self, request):
          """修改证书
  
          :param request: Request instance for ModifyLiveCert.
          :type request: :class:`tencentcloud.live.v20180801.models.ModifyLiveCertRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.ModifyLiveCertResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("ModifyLiveCert", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.ModifyLiveCertResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def ModifyLiveDomainCert(self, request):
          """修改域名和证书绑定信息
  
          :param request: Request instance for ModifyLiveDomainCert.
          :type request: :class:`tencentcloud.live.v20180801.models.ModifyLiveDomainCertRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.ModifyLiveDomainCertResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("ModifyLiveDomainCert", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.ModifyLiveDomainCertResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def ModifyLiveDomainReferer(self, request):
          """设置直播域名 Referer 黑白名单。
          由于 Referer 信息包含在 http 协议中，在开启配置后，播放协议为 rtmp 或 WebRTC 不会校验 Referer 配置，仍可正常播放。如需配置 Referer 鉴权建议使用 http-flv 或 http-hls 协议播放。
  
          :param request: Request instance for ModifyLiveDomainReferer.
          :type request: :class:`tencentcloud.live.v20180801.models.ModifyLiveDomainRefererRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.ModifyLiveDomainRefererResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("ModifyLiveDomainReferer", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.ModifyLiveDomainRefererResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def ModifyLivePlayAuthKey(self, request):
          """修改播放鉴权key
  
          :param request: Request instance for ModifyLivePlayAuthKey.
          :type request: :class:`tencentcloud.live.v20180801.models.ModifyLivePlayAuthKeyRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.ModifyLivePlayAuthKeyResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("ModifyLivePlayAuthKey", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.ModifyLivePlayAuthKeyResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def ModifyLivePlayDomain(self, request):
          """修改播放域名信息。
  
          :param request: Request instance for ModifyLivePlayDomain.
          :type request: :class:`tencentcloud.live.v20180801.models.ModifyLivePlayDomainRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.ModifyLivePlayDomainResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("ModifyLivePlayDomain", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.ModifyLivePlayDomainResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def ModifyLivePullStreamTask(self, request):
          """更新直播拉流任务。
          1. 不支持修改目标地址，如需推到新地址，请创建新任务。
          2. 不支持修改任务类型，如需更换，请创建新任务。
  
          :param request: Request instance for ModifyLivePullStreamTask.
          :type request: :class:`tencentcloud.live.v20180801.models.ModifyLivePullStreamTaskRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.ModifyLivePullStreamTaskResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("ModifyLivePullStreamTask", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.ModifyLivePullStreamTaskResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def ModifyLivePushAuthKey(self, request):
          """修改直播推流鉴权key
  
          :param request: Request instance for ModifyLivePushAuthKey.
          :type request: :class:`tencentcloud.live.v20180801.models.ModifyLivePushAuthKeyRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.ModifyLivePushAuthKeyResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("ModifyLivePushAuthKey", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.ModifyLivePushAuthKeyResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def ModifyLiveRecordTemplate(self, request):
          """修改录制模板配置。
  
          :param request: Request instance for ModifyLiveRecordTemplate.
          :type request: :class:`tencentcloud.live.v20180801.models.ModifyLiveRecordTemplateRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.ModifyLiveRecordTemplateResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("ModifyLiveRecordTemplate", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.ModifyLiveRecordTemplateResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def ModifyLiveSnapshotTemplate(self, request):
          """修改截图模板配置。
  
          :param request: Request instance for ModifyLiveSnapshotTemplate.
          :type request: :class:`tencentcloud.live.v20180801.models.ModifyLiveSnapshotTemplateRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.ModifyLiveSnapshotTemplateResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("ModifyLiveSnapshotTemplate", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.ModifyLiveSnapshotTemplateResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def ModifyLiveTranscodeTemplate(self, request):
          """修改转码模板配置。
  
          :param request: Request instance for ModifyLiveTranscodeTemplate.
          :type request: :class:`tencentcloud.live.v20180801.models.ModifyLiveTranscodeTemplateRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.ModifyLiveTranscodeTemplateResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("ModifyLiveTranscodeTemplate", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.ModifyLiveTranscodeTemplateResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def ModifyPullStreamConfig(self, request):
          """更新拉流配置。
  
          :param request: Request instance for ModifyPullStreamConfig.
          :type request: :class:`tencentcloud.live.v20180801.models.ModifyPullStreamConfigRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.ModifyPullStreamConfigResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("ModifyPullStreamConfig", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.ModifyPullStreamConfigResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def ModifyPullStreamStatus(self, request):
          """修改直播拉流配置的状态。
  
          :param request: Request instance for ModifyPullStreamStatus.
          :type request: :class:`tencentcloud.live.v20180801.models.ModifyPullStreamStatusRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.ModifyPullStreamStatusResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("ModifyPullStreamStatus", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.ModifyPullStreamStatusResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def ResumeDelayLiveStream(self, request):
          """取消直播流设置的延时配置，恢复实时直播画面。
  
          :param request: Request instance for ResumeDelayLiveStream.
          :type request: :class:`tencentcloud.live.v20180801.models.ResumeDelayLiveStreamRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.ResumeDelayLiveStreamResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("ResumeDelayLiveStream", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.ResumeDelayLiveStreamResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def ResumeLiveStream(self, request):
          """恢复某条流的推流。
  
          :param request: Request instance for ResumeLiveStream.
          :type request: :class:`tencentcloud.live.v20180801.models.ResumeLiveStreamRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.ResumeLiveStreamResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("ResumeLiveStream", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.ResumeLiveStreamResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def StopLiveRecord(self, request):
          """说明：录制后的文件存放于点播平台。用户如需使用录制功能，需首先自行开通点播账号并确保账号可用。录制文件存放后，相关费用（含存储以及下行播放流量）按照点播平台计费方式收取，请参考对应文档。
  
          :param request: Request instance for StopLiveRecord.
          :type request: :class:`tencentcloud.live.v20180801.models.StopLiveRecordRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.StopLiveRecordResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("StopLiveRecord", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.StopLiveRecordResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def StopRecordTask(self, request):
          """提前结束录制，并中止运行中的录制任务。任务被成功终止后，本次任务将不再启动。
  
          :param request: Request instance for StopRecordTask.
          :type request: :class:`tencentcloud.live.v20180801.models.StopRecordTaskRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.StopRecordTaskResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("StopRecordTask", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.StopRecordTaskResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def UnBindLiveDomainCert(self, request):
          """解绑域名证书
  
          :param request: Request instance for UnBindLiveDomainCert.
          :type request: :class:`tencentcloud.live.v20180801.models.UnBindLiveDomainCertRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.UnBindLiveDomainCertResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("UnBindLiveDomainCert", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.UnBindLiveDomainCertResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)
  
  
      def UpdateLiveWatermark(self, request):
          """更新水印。
  
          :param request: Request instance for UpdateLiveWatermark.
          :type request: :class:`tencentcloud.live.v20180801.models.UpdateLiveWatermarkRequest`
          :rtype: :class:`tencentcloud.live.v20180801.models.UpdateLiveWatermarkResponse`
  
          """
          try:
              params = request._serialize()
              body = self.call("UpdateLiveWatermark", params)
              response = json.loads(body)
              if "Error" not in response["Response"]:
                  model = models.UpdateLiveWatermarkResponse()
                  model._deserialize(response["Response"])
                  return model
              else:
                  code = response["Response"]["Error"]["Code"]
                  message = response["Response"]["Error"]["Message"]
                  reqid = response["Response"]["RequestId"]
                  raise TencentCloudSDKException(code, message, reqid)
          except Exception as e:
              if isinstance(e, TencentCloudSDKException):
                  raise
              else:
                  raise TencentCloudSDKException(e.message, e.message)