def find_all(_connection=None, page_size=100, page_number=0,
sort_by=enums.DEFAULT_SORT_BY, sort_order=enums.DEFAULT_SORT_ORDER):
"""
List all videos.
"""
return connection.ItemResultSet('find_all_videos', Video,
_connection, page_size, page_number, sort_by, sort_order)
def find_modified(since,
filter_list=None,
_connection=None,
page_size=25,
page_number=0,
sort_by=enums.DEFAULT_SORT_BY,
sort_order=enums.DEFAULT_SORT_ORDER,
**kwargs):
"""
List all videos modified since a certain date.
"""
filters = []
if filter_list is not None:
filters = filter_list
if isinstance(since, datetime):
fdate = int(since.strftime("%s")) / 60 # Minutes since UNIX time
elif since == 0:
fdate = '0' # This should be a string, otherwise kwargs
# thinks it's not existent
else:
msg = 'The parameter "since" must be a datetime object.'
raise exceptions.PyBrightcoveError(msg)
kwargs = Video.ensure_essential_fields(**kwargs)
return connection.ItemResultSet('find_modified_videos',
Video,
_connection,
page_size,
page_number,
sort_by,
sort_order,
from_date=fdate,
filter=filters,
**kwargs)
def find_by_ids(ids,
_connection=None,
page_size=100,
page_number=0,
sort_by=enums.DEFAULT_SORT_BY,
sort_order=enums.DEFAULT_SORT_ORDER,
**kwargs):
"""
List all videos identified by a list of Brightcove video ids
"""
if not isinstance(ids, (list, tuple)):
err = "Video.find_by_ids expects an iterable argument"
raise exceptions.PyBrightcoveError(err)
ids = ','.join([str(i) for i in ids])
apicall = 'find_videos_by_ids'
if kwargs.get('unfiltered'):
apicall = 'find_videos_by_ids_unfiltered'
kwargs = Video.ensure_essential_fields(**kwargs)
return connection.ItemResultSet(apicall,
Video,
_connection,
page_size,
page_number,
sort_by,
sort_order,
video_ids=ids,
**kwargs)
def find_by_tags(and_tags=None, or_tags=None, _connection=None,
page_size=100, page_number=0, sort_by=enums.DEFAULT_SORT_BY,
sort_order=enums.DEFAULT_SORT_ORDER):
"""
List videos given a certain set of tags.
"""
err = None
if not and_tags and not or_tags:
err = "You must supply at least one of either and_tags or or_tags."
if and_tags and not isinstance(and_tags, (tuple, list)):
err = "The and_tags argument for Video.find_by_tags must an "
err += "iterable"
if or_tags and not isinstance(or_tags, (tuple, list)):
err = "The or_tags argument for Video.find_by_tags must an "
err += "iterable"
if err:
raise exceptions.PyBrightcoveError(err)
atags = None
otags = None
if and_tags:
atags = ','.join([str(t) for t in and_tags])
if or_tags:
otags = ','.join([str(t) for t in or_tags])
return connection.ItemResultSet('find_videos_by_tags',
Video, _connection, page_size, page_number, sort_by, sort_order,
and_tags=atags, or_tags=otags)
def find_modified(since,
filter_list=None,
_connection=None,
page_size=25,
page_number=0,
sort_by=enums.DEFAULT_SORT_BY,
sort_order=enums.DEFAULT_SORT_ORDER):
"""
List all videos modified since a certain date.
"""
filters = []
if filter_list is not None:
filters = filter_list
if not isinstance(since, datetime):
msg = 'The parameter "since" must be a datetime object.'
raise exceptions.PyBrightcoveError(msg)
fdate = int(since.strftime("%s")) / 60 ## Minutes since UNIX time
return connection.ItemResultSet('find_modified_videos',
Video,
_connection,
page_size,
page_number,
sort_by,
sort_order,
from_date=fdate,
filter=filters)
def find_by_user(user_id, _connection=None, page_size=100, page_number=0,
sort_by=enums.DEFAULT_SORT_BY, sort_order=enums.DEFAULT_SORT_ORDER):
"""
List all videos uploaded by a certain user.
"""
return connection.ItemResultSet('find_videos_by_user_id',
Video, _connection, page_size, page_number, sort_by, sort_order,
user_id=user_id)
def find_by_text(text, _connection=None, page_size=100, page_number=0,
sort_by=enums.DEFAULT_SORT_BY, sort_order=enums.DEFAULT_SORT_ORDER):
"""
List videos that match the ``text`` in title or description.
"""
return connection.ItemResultSet('find_videos_by_text',
Video, _connection, page_size, page_number, sort_by, sort_order,
text=text)
def find_related(self, _connection=None, page_size=100, page_number=0):
"""
List all videos that are related to this one.
"""
if self.id:
return connection.ItemResultSet('find_related_videos',
Video, _connection, page_size, page_number, None, None,
video_id=self.id)
def find_by_campaign(campaign_id, _connection=None, page_size=100,
page_number=0, sort_by=enums.DEFAULT_SORT_BY,
sort_order=enums.DEFAULT_SORT_ORDER):
"""
List all videos for a given campaign.
"""
return connection.ItemResultSet(
'find_videos_by_campaign_id', Video, _connection, page_size,
page_number, sort_by, sort_order, campaign_id=campaign_id)
def find_by_ids(ids, _connection=None, page_size=100, page_number=0,
sort_by=enums.DEFAULT_SORT_BY, sort_order=enums.DEFAULT_SORT_ORDER):
"""
List all videos identified by a list of Brightcove video ids
"""
if not isinstance(ids, (list, tuple)):
err = "Video.find_by_ids expects an iterable argument"
raise exceptions.PyBrightcoveError(err)
ids = ','.join([str(i) for i in ids])
return connection.ItemResultSet('find_videos_by_ids',
Video, _connection, page_size, page_number, sort_by, sort_order,
video_ids=ids)
def find_all(_connection=None,
page_size=100,
page_number=0,
sort_by=enums.DEFAULT_SORT_BY,
sort_order=enums.DEFAULT_SORT_ORDER,
**kwargs):
"""
List all videos.
"""
kwargs = Video.ensure_essential_fields(**kwargs)
return connection.ItemResultSet('find_all_videos', Video, _connection,
page_size, page_number, sort_by,
sort_order, **kwargs)
def find_related(self,
_connection=None,
page_size=100,
page_number=0,
**kwargs):
"""
List all videos that are related to this one.
"""
if self.id:
kwargs = Video.ensure_essential_fields(**kwargs)
return connection.ItemResultSet('find_related_videos',
Video,
_connection,
page_size,
page_number,
None,
None,
video_id=self.id,
**kwargs)
def find_by_text(text,
_connection=None,
page_size=100,
page_number=0,
sort_by=enums.DEFAULT_SORT_BY,
sort_order=enums.DEFAULT_SORT_ORDER,
**kwargs):
"""
List videos that match the ``text`` in title or description.
"""
kwargs = Video.ensure_essential_fields(**kwargs)
return connection.ItemResultSet('find_videos_by_text',
Video,
_connection,
page_size,
page_number,
sort_by,
sort_order,
text=text,
**kwargs)
def find_by_user(user_id,
_connection=None,
page_size=100,
page_number=0,
sort_by=enums.DEFAULT_SORT_BY,
sort_order=enums.DEFAULT_SORT_ORDER,
**kwargs):
"""
List all videos uploaded by a certain user.
"""
kwargs = Video.ensure_essential_fields(**kwargs)
return connection.ItemResultSet('find_videos_by_user_id',
Video,
_connection,
page_size,
page_number,
sort_by,
sort_order,
user_id=user_id,
**kwargs)
def find_by_campaign(campaign_id,
_connection=None,
page_size=100,
page_number=0,
sort_by=enums.DEFAULT_SORT_BY,
sort_order=enums.DEFAULT_SORT_ORDER,
**kwargs):
"""
List all videos for a given campaign.
"""
kwargs = Video.ensure_essential_fields(**kwargs)
return connection.ItemResultSet('find_videos_by_campaign_id',
Video,
_connection,
page_size,
page_number,
sort_by,
sort_order,
campaign_id=campaign_id,
**kwargs)
def search_videos(all=None,
any=None,
none=None,
_connection=None,
page_size=100,
page_number=0,
sort_by=enums.DEFAULT_SORT_BY,
sort_order=enums.DEFAULT_SORT_ORDER):
"""
List videos given a certain set criteria.
"""
err = None
if not all and not any and not none:
err = "You must supply at least one of either all or and or none parameters."
if all and not isinstance(all, (tuple, list)):
err = "The all argument for Video.search_videos must an "
err += "iterable"
if any and not isinstance(any, (tuple, list)):
err = "The any argument for Video.search_videos must an "
err += "iterable"
if err:
raise exceptions.PyBrightcoveError(err)
allstr = None
anystr = None
nonestr = None
if all:
allstr = '&all='.join([str(t) for t in all])
if any:
anystr = '&any='.join([str(t) for t in any])
if none:
nonestr = '&none='.join([str(t) for t in none])
return connection.ItemResultSet('search_videos',
Video,
_connection,
page_size,
page_number,
sort_by,
sort_order,
all=allstr,
any=anystr,
none=nonestr)
class Video(object):
"""
The Video object is an aggregation of metadata and asset information
associated with a video.
"""
# pylint: disable=W0622
def __init__(self, filename=None, name=None, short_description=None,
id=None, reference_id=None, renditions=None, data=None,
_connection=None):
self._filename = None
self.name = None
self.short_description = None
self.id = None
self.reference_id = None
self.accountId = None
self.long_description = None
self.flv_url = None
self.renditions = []
self.assets = []
self.metadata = []
self.video_full_length = None
self.creation_date = None
self.published_date = None
self.last_modified_date = None
self.item_state = None
self.start_date = None
self.end_date = None
self.link_url = None
self.link_text = None
self.tags = []
self.video_still_url = None
self.thumbnail_url = None
self.length = None
self.economics = None
self.geo_filtered = None
self.geo_filtered_countries = None
self.geo_filtered_exclude = None
self.cue_points = None
self.plays_total = None
self.plays_trailing_week = None
self.image = None
self.raw_data = None
self.connection = _connection
if not self.connection:
self.connection = connection.APIConnection()
if is_ftp_connection(self.connection):
if reference_id and name and short_description:
self.reference_id = reference_id
self.name = name
self.short_description = short_description
else:
msg = "Invalid parameters for Video."
raise exceptions.PyBrightcoveError(msg)
else:
if ((renditions and len(renditions) > 0) or filename) and name \
and short_description:
if filename is not None:
self._filename = filename
if renditions is not None:
self.renditions = renditions
self.name = name
self.short_description = short_description
elif id or reference_id:
self.id = id
self.reference_id = reference_id
self._find_video()
elif data:
self._load(data)
else:
msg = "Invalid parameters for Video."
raise exceptions.PyBrightcoveError(msg)
def _find_video(self):
"""
Lookup and populate ``pybrightcove.video.Video`` object given a video
id or reference_id.
"""
data = None
if self.id:
data = self.connection.get_item(
'find_video_by_id', video_id=self.id)
elif self.reference_id:
data = self.connection.get_item(
'find_video_by_reference_id', reference_id=self.reference_id)
if data:
self._load(data)
def _to_dict(self):
"""
Converts object into a dictionary.
"""
for i, tag in enumerate(self.tags):
if tag in ("", None):
self.tags.pop(i)
data = {
'name': self.name,
'referenceId': self.reference_id,
'shortDescription': self.short_description,
'longDescription': self.long_description,
'itemState': self.item_state,
'linkURL': self.link_url,
'linkText': self.link_text,
'tags': self.tags,
'economics': self.economics,
'id': self.id,
'end_date': _make_tstamp(self.end_date),
'start_date': _make_tstamp(self.start_date)}
if len(self.renditions) > 0:
data['renditions'] = []
for r in self.renditions:
data['renditions'].append(r.to_dict())
if len(self.metadata) > 0:
data['customFields'] = {}
for meta in self.metadata:
data['customFields'][meta['key']] = meta['value']
[data.pop(key) for key in data.keys() if data[key] == None]
return data
def to_xml(self):
# pylint: disable=R0912
"""
Converts object into an XML string.
"""
xml = ''
for asset in self.assets:
xml += '<asset filename="%s" ' % \
os.path.basename(asset['filename'])
xml += ' refid=%s' % quoteattr(asset['refid'])
xml += ' size="%(size)s"' % asset
xml += ' hash-code=%s' % quoteattr(asset['hash-code'])
xml += ' type=%s' % quoteattr(asset['type'])
if asset.get('encoding-rate', None):
xml += ' encoding-rate="%s"' % asset['encoding-rate']
if asset.get('frame-width', None):
xml += ' frame-width="%s"' % asset['frame-width']
if asset.get('frame-height', None):
xml += ' frame-height="%s"' % asset['frame-height']
if asset.get('display-name', None):
xml += ' display-name=%s' % quoteattr(asset['display-name'])
if asset.get('encode-to', None):
xml += ' encode-to=%s' % quoteattr(asset['encode-to'])
if asset.get('encode-multiple', None):
xml += ' encode-multiple="%s"' % asset['encode-multiple']
if asset.get('h264-preserve-as-rendition', None):
xml += ' h264-preserve-as-rendition="%s"' % \
asset['h264-preserve-as-rendition']
if asset.get('h264-no-processing', None):
xml += ' h264-no-processing=%s' % quoteattr(asset['h264-no-processing'])
xml += ' />\n'
self_dict = self._to_dict()
xml += '<title name=%s refid=%s active="TRUE" ' % (quoteattr(self_dict['name']),
quoteattr(self_dict['referenceId']))
if self.start_date:
xml += 'start-date="%(start_date)s" '
if self.end_date:
xml += 'end-date="%(end_date)s" '
for asset in self.assets:
if asset.get('encoding-rate', None) == None:
choice = enums.AssetTypeEnum
if asset.get('type', None) == choice.VIDEO_FULL:
xml += 'video-full-refid=%s ' % quoteattr(asset.get('refid'))
if asset.get('type', None) == choice.THUMBNAIL:
xml += 'thumbnail-refid=%s ' % quoteattr(asset.get('refid'))
if asset.get('type', None) == choice.VIDEO_STILL:
xml += 'video-still-refid=%s ' % quoteattr(asset.get('refid'))
if asset.get('type', None) == choice.FLV_BUMPER:
xml += 'flash-prebumper-refid=%s ' % quoteattr(asset.get('refid'))
xml += '>\n'
if self.short_description:
xml += '<short-description><![CDATA[%(shortDescription)s]]>'
xml += '</short-description>\n'
if self.long_description:
xml += '<long-description><![CDATA[%(longDescription)s]]>'
xml += '</long-description>\n'
for tag in self.tags:
xml += '<tag><![CDATA[%s]]></tag>\n' % tag
for asset in self.assets:
if asset.get('encoding-rate', None):
xml += '<rendition-refid>%s</rendition-refid>\n' % \
asset['refid']
for meta in self.metadata:
xml += '<custom-%s-value name=%s>%s</custom-%s-value>' % \
(meta['type'], quoteattr(meta['key']), meta['value'], meta['type'])
xml += '</title>'
xml = xml % self._to_dict()
return xml
def _load(self, data):
"""
Deserialize a dictionary of data into a ``pybrightcove.video.Video``
object.
"""
self.raw_data = data
self.creation_date = _convert_tstamp(data['creationDate'])
self.economics = data['economics']
self.id = data['id']
self.last_modified_date = _convert_tstamp(data['lastModifiedDate'])
self.length = data['length']
self.link_text = data['linkText']
self.link_url = data['linkURL']
self.long_description = data['longDescription']
self.name = data['name']
self.plays_total = data['playsTotal']
self.plays_trailing_week = data['playsTrailingWeek']
self.published_date = _convert_tstamp(data['publishedDate'])
self.start_date = _convert_tstamp(data.get('startDate', None))
self.end_date = _convert_tstamp(data.get('endDate', None))
self.reference_id = data['referenceId']
self.short_description = data['shortDescription']
self.tags = []
for tag in data['tags']:
self.tags.append(tag)
self.thumbnail_url = data['thumbnailURL']
self.video_still_url = data['videoStillURL']
def __setattr__(self, name, value):
msg = None
if value:
if name == 'name' and len(value) > 255:
msg = "Video.name must be 255 characters or less."
if name == 'reference_id' and len(value) > 150:
# val = value[:150]
msg = "Video.reference_id must be 150 characters or less."
if name == 'long_description' and len(value) > 5000:
# val = value[:5000]
msg = "Video.long_description must be 5000 characters or less."
if name == 'short_description' and len(value) > 250:
# val = value[:250]
msg = "Video.short_description must be 250 characters or less."
if name == 'item_state' and value not in (
enums.ItemStateEnum.ACTIVE,
enums.ItemStateEnum.INACTIVE):
msg = "Video.item_state must be either ItemStateEnum.ACTIVE or"
msg += " ItemStateEnum.INACTIVE"
if name == 'video_full_length' and \
not isinstance(value, Rendition):
msg = "Video.video_full_length must be of type Rendition"
if name == 'economics' and value not in \
(enums.EconomicsEnum.FREE,
enums.EconomicsEnum.AD_SUPPORTED):
msg = "Video.economics must be either EconomicsEnum.FREE or "
msg += "EconomicsEnum.AD_SUPPORTED"
if msg:
raise exceptions.PyBrightcoveError(msg)
return super(Video, self).__setattr__(name, value)
def get_custom_metadata(self):
"""
Fetches custom metadta for an already exisiting Video.
"""
if self.id is not None:
data = self.connection.get_item(
'find_video_by_id',
video_id=self.id,
video_fields="customFields"
)
for key in data.get("customFields", {}).keys():
val = data["customFields"].get(key)
if val is not None:
self.add_custom_metadata(key, val)
def add_custom_metadata(self, key, value, meta_type=None):
"""
Add custom metadata to the Video. meta_type is required for XML API.
"""
self.metadata.append({'key': key, 'value': value, 'type': meta_type})
def add_asset(self, filename, asset_type, display_name,
encoding_rate=None, frame_width=None, frame_height=None,
encode_to=None, encode_multiple=False,
h264_preserve_as_rendition=False, h264_no_processing=False, refid=None):
"""
Add an asset to the Video object.
"""
m = hashlib.md5()
fp = file(filename, 'rb')
bits = fp.read(262144) ## 256KB
while bits:
m.update(bits)
bits = fp.read(262144)
fp.close()
hash_code = m.hexdigest()
if not refid:
refid = "%s-%s" % (os.path.basename(filename), hash_code)
asset = {
'filename': filename,
'type': asset_type,
'size': os.path.getsize(filename),
'refid': refid,
'hash-code': hash_code}
if encoding_rate:
asset.update({'encoding-rate': encoding_rate})
if frame_width:
asset.update({'frame-width': frame_width})
if frame_height:
asset.update({'frame-height': frame_height})
if display_name:
asset.update({'display-name': display_name})
if encode_to:
asset.update({'encode-to': encode_to})
asset.update({'encode-multiple': encode_multiple})
if encode_multiple and h264_preserve_as_rendition:
asset.update({
'h264-preserve-as-rendition': h264_preserve_as_rendition})
else:
if h264_no_processing:
asset.update({'h264-no-processing': h264_no_processing})
self.assets.append(asset)
def save(self, create_multiple_renditions=True,
preserve_source_rendition=True,
encode_to=enums.EncodeToEnum.FLV,
batched=False):
"""
Creates or updates the video
"""
if is_ftp_connection(self.connection) and len(self.assets) > 0:
if batched:
self.connection.add_batched_video(xml=self.to_xml(), assets=self.assets)
else:
self.connection.post(xml=self.to_xml(), assets=self.assets)
elif not self.id and self._filename:
self.id = self.connection.post('create_video', self._filename,
create_multiple_renditions=create_multiple_renditions,
preserve_source_rendition=preserve_source_rendition,
encode_to=encode_to,
video=self._to_dict())
elif not self.id and len(self.renditions) > 0:
self.id = self.connection.post('create_video',
video=self._to_dict())
elif self.id:
data = self.connection.post('update_video', video=self._to_dict())
if data:
self._load(data)
def delete(self, cascade=False, delete_shares=False):
"""
Deletes the video.
"""
if self.id:
self.connection.post('delete_video', video_id=self.id,
cascade=cascade, delete_shares=delete_shares)
self.id = None ## Prevent more activity on this video id
def get_upload_status(self):
"""
Get the status of the video that has been uploaded.
"""
if self.id:
return self.connection.post('get_upload_status', video_id=self.id)
def share(self, accounts):
"""
Create a share
"""
if not isinstance(accounts, (list, tuple)):
msg = "Video.share expects an iterable argument"
raise exceptions.PyBrightcoveError(msg)
raise exceptions.PyBrightcoveError("Not yet implemented")
def set_image(self, image, filename=None, resize=False):
"""
Set the poster or thumbnail of a this Vidoe.
"""
if self.id:
data = self.connection.post('add_image', filename,
video_id=self.id, image=image.to_dict(), resize=resize)
if data:
self.image = Image(data=data)
def find_related(self, _connection=None, page_size=100, page_number=0):
"""
List all videos that are related to this one.
"""
if self.id:
return connection.ItemResultSet('find_related_videos',
Video, _connection, page_size, page_number, None, None,
video_id=self.id)
def deactivate(self):
"""
Mark a video as Inactive
"""
self.item_state = enums.ItemStateEnum.INACTIVE
self.save()
@staticmethod
def delete_video(video_id, cascade=False, delete_shares=False,
_connection=None):
"""
Delete the video represented by the ``video_id`` parameter.
"""
c = _connection
if not c:
c = connection.APIConnection()
c.post('delete_video', video_id=video_id, cascade=cascade,
delete_shares=delete_shares)
@staticmethod
def get_status(video_id=None, reference_id=None, _connection=None):
"""
Get the status of a video given the ``video_id`` parameter.
"""
args = {}
if video_id:
args = {'video_id': video_id}
elif reference_id:
args = {'reference_id': reference_id}
else:
msg = 'get_status needs either a video_id or a reference_id'
raise exceptions.PyBrightcoveError(msg)
c = _connection
if not c:
c = connection.APIConnection()
return c.post('get_upload_status', **args)
@staticmethod
def activate(video_id, _connection=None):
"""
Mark a video as Active
"""
c = _connection
if not c:
c = connection.APIConnection()
data = c.post('update_video', video={
'id': video_id,
'itemState': enums.ItemStateEnum.ACTIVE})
return Video(data=data, _connection=c)
@staticmethod
def find_modified(since, filter_list=None, _connection=None, page_size=25,
page_number=0, sort_by=enums.DEFAULT_SORT_BY,
sort_order=enums.DEFAULT_SORT_ORDER):
"""
List all videos modified since a certain date.
"""
filters = []
if filter_list is not None:
filters = filter_list
if not isinstance(since, datetime):
msg = 'The parameter "since" must be a datetime object.'
raise exceptions.PyBrightcoveError(msg)
fdate = int(since.strftime("%s")) / 60 ## Minutes since UNIX time
return connection.ItemResultSet('find_modified_videos',
Video, _connection, page_size, page_number, sort_by, sort_order,
from_date=fdate, filter=filters)
@staticmethod
def find_all(_connection=None, page_size=100, page_number=0,
sort_by=enums.DEFAULT_SORT_BY, sort_order=enums.DEFAULT_SORT_ORDER):
"""
List all videos.
"""
return connection.ItemResultSet('find_all_videos', Video,
_connection, page_size, page_number, sort_by, sort_order)
@staticmethod
def find_by_tags(and_tags=None, or_tags=None, _connection=None,
page_size=100, page_number=0, sort_by=enums.DEFAULT_SORT_BY,
sort_order=enums.DEFAULT_SORT_ORDER):
"""
List videos given a certain set of tags.
"""
err = None
if not and_tags and not or_tags:
err = "You must supply at least one of either and_tags or or_tags."
if and_tags and not isinstance(and_tags, (tuple, list)):
err = "The and_tags argument for Video.find_by_tags must an "
err += "iterable"
if or_tags and not isinstance(or_tags, (tuple, list)):
err = "The or_tags argument for Video.find_by_tags must an "
err += "iterable"
if err:
raise exceptions.PyBrightcoveError(err)
atags = None
otags = None
if and_tags:
atags = ','.join([str(t) for t in and_tags])
if or_tags:
otags = ','.join([str(t) for t in or_tags])
return connection.ItemResultSet('find_videos_by_tags',
Video, _connection, page_size, page_number, sort_by, sort_order,
and_tags=atags, or_tags=otags)
@staticmethod
def find_by_text(text, _connection=None, page_size=100, page_number=0,
sort_by=enums.DEFAULT_SORT_BY, sort_order=enums.DEFAULT_SORT_ORDER):
"""
List videos that match the ``text`` in title or description.
"""
return connection.ItemResultSet('find_videos_by_text',
Video, _connection, page_size, page_number, sort_by, sort_order,
text=text)
@staticmethod
def find_by_campaign(campaign_id, _connection=None, page_size=100,
page_number=0, sort_by=enums.DEFAULT_SORT_BY,
sort_order=enums.DEFAULT_SORT_ORDER):
"""
List all videos for a given campaign.
"""
return connection.ItemResultSet(
'find_videos_by_campaign_id', Video, _connection, page_size,
page_number, sort_by, sort_order, campaign_id=campaign_id)
@staticmethod
def find_by_user(user_id, _connection=None, page_size=100, page_number=0,
sort_by=enums.DEFAULT_SORT_BY, sort_order=enums.DEFAULT_SORT_ORDER):
"""
List all videos uploaded by a certain user.
"""
return connection.ItemResultSet('find_videos_by_user_id',
Video, _connection, page_size, page_number, sort_by, sort_order,
user_id=user_id)
@staticmethod
def find_by_reference_ids(reference_ids, _connection=None, page_size=100,
page_number=0, sort_by=enums.DEFAULT_SORT_BY,
sort_order=enums.DEFAULT_SORT_ORDER):
"""
List all videos identified by a list of reference ids
"""
try:
ids = ','.join(reference_ids)
except TypeError, exc:
err = "Video.find_by_reference_ids expects an iterable argument"
raise exceptions.PyBrightcoveError(err)
return connection.ItemResultSet(
'find_videos_by_reference_ids', Video, _connection, page_size,
page_number, sort_by, sort_order, reference_ids=ids)
page_number=0, sort_by=enums.DEFAULT_SORT_BY,
sort_order=enums.DEFAULT_SORT_ORDER):
"""
List all videos identified by a list of reference ids
"""
try:
ids = ','.join(reference_ids)
except TypeError, exc:
err = "Video.find_by_reference_ids expects an iterable argument"
raise exceptions.PyBrightcoveError(err)
return connection.ItemResultSet(
'find_videos_by_reference_ids', Video, _connection, page_size,
page_number, sort_by, sort_order, reference_ids=ids)
@staticmethod
def find_by_ids(ids, _connection=None, page_size=100, page_number=0,
sort_by=enums.DEFAULT_SORT_BY, sort_order=enums.DEFAULT_SORT_ORDER):
"""
List all videos identified by a list of Brightcove video ids
"""
try:
ids = ','.join([str(i) for i in ids])
except TypeError, exc:
err = "Video.find_by_ids expects an iterable argument"
raise exceptions.PyBrightcoveError(err)
return connection.ItemResultSet('find_videos_by_ids',
Video, _connection, page_size, page_number, sort_by, sort_order,
video_ids=ids)
