def __init__(self,
codec_configuration_id,
input_streams=None,
outputs=None,
id_=None,
custom_data=None,
name=None,
description=None,
conditions=None,
ignored_by=None):
super().__init__(id_=id_,
custom_data=custom_data,
name=name,
description=description)
self._inputStreams = None
self._outputs = None
self._conditions = None
self._ignoredBy = None
self.codecConfigId = codec_configuration_id
self.conditions = conditions
if input_streams is not None and not isinstance(input_streams, list):
raise InvalidTypeError('input_streams must be a list')
self.inputStreams = input_streams
if outputs is not None and not isinstance(outputs, list):
raise InvalidTypeError('outputs must be a list')
self.outputs = outputs
if ignored_by is not None and not isinstance(ignored_by, list):
raise InvalidTypeError('ignoredBy must be a list')
self.ignored_by = ignored_by
def __init__(self,
streams,
outputs=None,
id_=None,
custom_data=None,
name=None,
description=None,
avg_bitrate=None,
max_bitrate=None,
min_bitrate=None,
ignored_by=None):
super().__init__(id_=id_,
custom_data=custom_data,
name=name,
description=description)
self._streams = []
self._outputs = None
self._ignoredBy = None
if streams is None or not isinstance(streams, list):
raise InvalidTypeError('streams must be a list')
self.streams = streams
if outputs is not None and not isinstance(outputs, list):
raise InvalidTypeError('outputs must be a list')
self.outputs = outputs
self.avgBitrate = avg_bitrate
self.minBitrate = min_bitrate
self.maxBitrate = max_bitrate
if ignored_by is not None and not isinstance(ignored_by, list):
raise InvalidTypeError('ignoredBy must be a list')
self.ignored_by = ignored_by
def __init__(self,
height,
positions,
outputs,
pattern,
unit=None,
id_=None,
custom_data=None,
name=None,
description=None):
super().__init__(id_=id_,
custom_data=custom_data,
name=name,
description=description)
self._outputs = None
self._positions = None
self._unit = None
self.height = height
self.positions = positions
self.unit = unit
self.pattern = pattern
if not isinstance(positions, list):
raise InvalidTypeError('positions must be a list')
if outputs is not None and not isinstance(outputs, list):
raise InvalidTypeError('outputs must be a list')
self.outputs = outputs
self.positions = positions
def check_not_blank(cls, argument):
if not argument:
raise MissingArgumentError('argument must not be blank')
if not isinstance(argument, str):
raise InvalidTypeError('argument must be an str')
if argument == '':
raise InvalidTypeError('argument must not be blank')
def conditions(self, new_conditions):
if new_conditions is None:
return
if not isinstance(new_conditions, list):
raise InvalidTypeError('new_conditions has to be a list')
if all(isinstance(new_condition, AbstractCondition) for new_condition in new_conditions):
self._conditions = new_conditions
else:
raise InvalidTypeError('Invalid type for conditions list')
def labels(self, new_labels):
if new_labels is None:
self._labels = None
return
if not isinstance(new_labels, list):
raise InvalidTypeError('new_labels has to be a list of strings')
if all(isinstance(label, str) for label in new_labels):
self._labels = new_labels
else:
raise InvalidTypeError('new_labels has to be a list of strings')
def __init__(self,
height,
width,
sprite_name,
vtt_name,
outputs,
distance=None,
id_=None,
custom_data=None,
name=None,
description=None):
super().__init__(id_=id_,
custom_data=custom_data,
name=name,
description=description)
self._outputs = None
self.height = height
self.width = width
self.distance = distance
self.spriteName = sprite_name
self.vttName = vtt_name
if outputs is not None and not isinstance(outputs, list):
raise InvalidTypeError('outputs must be a list')
self.outputs = outputs
def prewarmedInstancePoolIds(self, new_prewarmed_instance_pool_ids):
if new_prewarmed_instance_pool_ids is None:
self._prewarmed_instance_pool_ids = None
return
if not isinstance(new_prewarmed_instance_pool_ids, list):
raise InvalidTypeError(
'prewarmedInstancePoolIds has to be a list of strings')
if all(
isinstance(pool_id, str)
for pool_id in new_prewarmed_instance_pool_ids):
self._prewarmed_instance_pool_ids = new_prewarmed_instance_pool_ids
else:
raise InvalidTypeError(
'prewarmedInstancePoolIds has to be a list of strings')
def crf(self, new_value):
if new_value is None:
return
if not isinstance(new_value, float):
raise InvalidTypeError('crf has to be a float value')
self._crf = new_value
def colorConfig(self, new_color_config):
if new_color_config is None:
self._colorConfig = None
elif isinstance(new_color_config, ColorConfig):
self._colorConfig = new_color_config
else:
raise InvalidTypeError('colorConfig has to be of type ColorConfig')
def openGop(self, new_value):
if new_value is None:
self._openGop = None
elif isinstance(new_value, bool):
self._openGop = new_value
else:
raise InvalidTypeError('openGop is a boolean variable')
def add_video_adaptation_set(self, object_, manifest_id, period_id):
if not isinstance(object_, VideoAdaptationSet):
raise InvalidTypeError(
'object_ has to be an instance of {}'.format(
VideoAdaptationSet.__name__))
url = self.relative_url
if not url.endswith('/'):
url += '/'
url = urljoin(
url, '{}/periods/{}/adaptationsets/video'.format(
manifest_id, period_id))
response = self.http_client.post(url, object_) # type: Response
if response.status == Status.ERROR.value:
raise BitmovinApiError(
'Response was not successful: {}'.format(
response.raw_response), response)
if response.status == Status.SUCCESS.value:
created_resource = self.parsing_utils.parse_bitmovin_resource_from_response(
response=response, class_=VideoAdaptationSet)
return ResourceResponse(response=response,
resource=created_resource)
raise InvalidStatusError('Unknown status {} received'.format(
response.status))
def add_content_protection_to_drm_fmp4_represenation(
self, object_, manifest_id, period_id, adaptationset_id,
representation_id):
if not isinstance(object_, ContentProtection):
raise InvalidTypeError(
'object_ has to be an instance of {}'.format(
ContentProtection.__name__))
url = self.relative_url
if not url.endswith('/'):
url += '/'
url = urljoin(
url,
'{}/periods/{}/adaptationsets/{}/representations/fmp4/drm/{}/contentprotection'
.format(manifest_id, period_id, adaptationset_id,
representation_id))
response = self.http_client.post(url, object_) # type: Response
if response.status == Status.ERROR.value:
raise BitmovinApiError(
'Response was not successful: {}'.format(
response.raw_response), response)
if response.status == Status.SUCCESS.value:
created_resource = self.parsing_utils.parse_bitmovin_resource_from_response(
response=response, class_=ContentProtection)
return ResourceResponse(response=response,
resource=created_resource)
raise InvalidStatusError('Unknown status {} received'.format(
response.status))
def __init__(self, concatenation, id_=None, custom_data=None, name=None, description=None):
super().__init__(id_=id_, custom_data=custom_data, name=name, description=description)
self._concatenation = None
if concatenation is not None and not isinstance(concatenation, list):
raise InvalidTypeError('concatenation must be a list')
self.concatenation = concatenation
def additionalInformation(self, new_additional_information):
if new_additional_information is None:
self._additional_information = None
elif isinstance(new_additional_information, PlayReadyDRMAdditionalInformation):
self._additional_information = new_additional_information
else:
raise InvalidTypeError('Invalid type {} for playReady: must be a PlayReadyDRMAdditionalInformation!'.format(
type(new_additional_information))
)
def marlin(self, new_marlin):
if new_marlin is None:
self._marlin = None
elif isinstance(new_marlin, CENCMarlinEntry):
self._marlin = new_marlin
else:
raise InvalidTypeError(
'Invalid type {} for marlin: must be a CENCMarlinEntry!'.
format(type(new_marlin)))
def fairPlay(self, new_fairplay):
if new_fairplay is None:
self._fairplay = None
elif isinstance(new_fairplay, CENCFairPlayEntry):
self._fairplay = new_fairplay
else:
raise InvalidTypeError(
'Invalid type {} for fairPlay: must be a CENCFairPlayEntry!'.
format(type(new_fairplay)))
def fragmentedMP4MuxingManifestType(self, new_fragmented_mp4_muxing_manifest_type):
if new_fragmented_mp4_muxing_manifest_type is None:
self._fragmentedMP4MuxingManifestType = None
elif isinstance(new_fragmented_mp4_muxing_manifest_type, MP4MuxingManifestType):
self._fragmentedMP4MuxingManifestType = new_fragmented_mp4_muxing_manifest_type.value
elif isinstance(new_fragmented_mp4_muxing_manifest_type, str):
self._fragmentedMP4MuxingManifestType = new_fragmented_mp4_muxing_manifest_type
else:
raise InvalidTypeError('fragmentedMP4MuxingManifestType has to be of type MP4MuxingManifestType or str')
def widevine(self, new_widevine):
if new_widevine is None:
self._widevine = None
elif isinstance(new_widevine, CENCWidevineEntry):
self._widevine = new_widevine
else:
raise InvalidTypeError(
'Invalid type {} for widevine: must be a CENCWidevineEntry!'.
format(type(new_widevine)))
def playReady(self, new_playready):
if new_playready is None:
self._playready = None
elif isinstance(new_playready, CENCPlayReadyEntry):
self._playready = new_playready
else:
raise InvalidTypeError(
'Invalid type {} for playReady: must be a CENCPlayReadyEntry!'.
format(type(new_playready)))
def infrastructure(self, new_infrastructure):
if new_infrastructure is None:
self._infrastructure = None
return
if isinstance(new_infrastructure, Infrastructure):
self._infrastructure = new_infrastructure
else:
raise InvalidTypeError(
'Invalid type {} for infrastructure: must be Infrastructure!'.
format(type(new_infrastructure)))
def bPyramid(self, new_b_pyramid):
if new_b_pyramid is None:
self._bPyramid = None
return
elif isinstance(new_b_pyramid, H264BPyramid):
self._bPyramid = new_b_pyramid.value
elif isinstance(new_b_pyramid, str):
self._bPyramid = new_b_pyramid
else:
raise InvalidTypeError('bPyramid has to be of type H264BPyramid')
def pixelFormat(self, new_format):
if new_format is None:
return
if isinstance(new_format, str):
self._pixel_format = new_format
elif isinstance(new_format, PixelFormat):
self._pixel_format = new_format.value
else:
raise InvalidTypeError(
'Invalid type {} for pixelFormat: must be either str or PixelFormat!'.format(type(new_format)))
def trimming(self, new_trimming):
if new_trimming is None:
self._trimming = None
return
if not isinstance(new_trimming, StartEncodingTrimming):
raise InvalidTypeError(
'Invalid type {} for trimming: must be StartEncodingTrimming!'.format(type(new_trimming)))
self._trimming = new_trimming
def tweaks(self, new_tweaks):
if new_tweaks is None:
self._tweaks = None
return
if not isinstance(new_tweaks, Tweaks):
raise InvalidTypeError(
'Invalid type {} for tweaks: must be an instance of Tweaks!'.format(type(new_tweaks)))
self._tweaks = new_tweaks
def timeCode(self, new_time_code):
if new_time_code is None:
self._timeCode = None
return
if isinstance(new_time_code, TimeCode):
self._timeCode = new_time_code
else:
raise InvalidTypeError(
'Invalid type {} for timeCode: must be TimeCode object!'.
format(type(new_time_code)))
def ivSize(self, new_iv_size):
if new_iv_size is None:
self._ivSize = None
return
elif isinstance(new_iv_size, IvSize):
self._ivSize = new_iv_size.value
elif isinstance(new_iv_size, str):
self._ivSize = new_iv_size
else:
raise InvalidTypeError('ivSize has to be of type IvSize')
def type(self, new_type):
if new_type is None:
return
if isinstance(new_type, str):
self._type = new_type
elif isinstance(new_type, ConditionType):
self._type = new_type.value
else:
raise InvalidTypeError(
'Invalid type {} for type: must be either str or ConditionType!'.format(type(new_type)))
def cea608708SubtitleConfig(self, new_cea_608_708_subtitle_config):
if new_cea_608_708_subtitle_config is None:
self._cea608708SubtitleConfig = None
elif isinstance(new_cea_608_708_subtitle_config,
Cea608708SubtitleConfig):
self._cea608708SubtitleConfig = new_cea_608_708_subtitle_config
else:
raise InvalidTypeError(
'cea608708SubtitleConfig has to be of type Cea608708SubtitleConfig'
)
def nalHrd(self, new_nal_hrd):
if new_nal_hrd is None:
self._nalHrd = None
return
elif isinstance(new_nal_hrd, H264NalHrd):
self._nalHrd = new_nal_hrd.value
elif isinstance(new_nal_hrd, str):
self._nalHrd = new_nal_hrd
else:
raise InvalidTypeError('nalHrd has to be of type H264NalHrd')
