def count():
flter = kaltura.Filter().page_size(1).status(DEFAULT_FILTER_STATUS_LIST)
print(str(flter))
print "ALL: {}".format(kaltura.Filter().page_size(1).status(
DEFAULT_FILTER_STATUS_LIST).get_count())
print "SAVED_TO_S3: {}".format(kaltura.Filter().page_size(1).status(
DEFAULT_FILTER_STATUS_LIST).tag(SAVED_TO_S3).get_count())
print "PLACE_HOLDER_VIDEO: {}".format(kaltura.Filter().page_size(1).status(
DEFAULT_FILTER_STATUS_LIST).tag(PLACE_HOLDER_VIDEO).get_count())
print("")
for year in range(8, 0, -1):
play_info_creation_year(year)
print("")
sum = 0
for year in range(5, 0, -1):
sum += year_status(year, False)
print("")
if (True):
print("")
print(
"TB of videos played in last year - ... - will take a while to compute"
)
year_status(1, True)
def test_overlap(self):
filter = kaltura.Filter().first_page(2).page_size(10).max_iter(1)
e = next(iter(filter))
filter = kaltura.Filter().first_page(1).page_size(10).max_iter(11)
e_ = list(filter)[-1]
self.assertEqual(e.getId(), e_.getId())
def test_overlap_SAVED_TO_S3(self):
filter = kaltura.Filter().first_page(3).page_size(1).max_iter(1).tag(
kaltura_aws.SAVED_TO_S3)
e = next(iter(filter))
filter = kaltura.Filter().first_page(2).page_size(1).max_iter(2).tag(
kaltura_aws.SAVED_TO_S3)
e_ = list(filter)[-1]
self.assertEqual(e.getId(), e_.getId())
def test_get_count(self):
cnt_s3 = kaltura.Filter().first_page(3).page_size(1).max_iter(1).tag(
kaltura_aws.SAVED_TO_S3).get_count()
self.assertTrue(cnt_s3 > 0)
cnt_s3_same = kaltura.Filter().first_page(100).page_size(1).tag(
kaltura_aws.SAVED_TO_S3).get_count()
self.assertTrue(cnt_s3 == cnt_s3_same)
cnt = kaltura.Filter().first_page(3).page_size(1).max_iter(
1).get_count()
self.assertTrue(cnt_s3 <= cnt)
def test_filter_played_within_unplayed_for_impossible(self):
filter = kaltura.Filter().played_within_years(1).years_since_played(
3).page_size(10).max_iter(10)
l = sum(1 for _ in filter)
self.assertEqual(
l, 0,
"expecting no videos played a year ago but unplayed for 3 years")
def _create_filter(params):
if ('idfile' in params and params['idfile']):
filter = IdFileIter(params['idfile'])
else:
filter = kaltura.Filter()
if ('id' in params):
filter.entry_id(params['id'])
if 'status' in params:
# implies all the other params are there too
# see ArgParser
filter.tag(params['tag'])
filter.category(params['category'])
filter.status(','.join(params['status']))
filter.plays_lt(params['plays'])
filter.years_since_played(params['unplayed_for']).played_within_years(params['played_within'])
filter.created_within_years(params['created_within']).years_since_created(params['created_before'])
filter.first_page(params['first_page']).page_size(params['page_size'])
filter.max_iter(params['max_entries'])
if (params['func'] == replace_videos):
if (not 'created_before' in params ):
kaltura.logger.info("Adding years_since_create = {} years to filter".format(YEARS_SINCE_CREATION_FOR_REPLACE))
filter.years_since_created(YEARS_SINCE_CREATION_FOR_REPLACE)
kaltura.logger.info("FILTER {}".format(filter))
return filter
def test_filter_created_within_created_before(self):
filter = kaltura.Filter().created_within_years(3).years_since_created(
1).page_size(10).max_iter(10)
sfilter = str(filter)
l = sum(1 for _ in filter)
self.assertGreater(
l, 0, "expecting some video created between 3 and 1 year ago ")
def __init__(self, file):
"""
file must contain kaltura ids / one per line
:param file: input file descriptor
"""
self.file = file
self.filter = kaltura.Filter()
def test_filter_created_within_created_before_impossible(self):
filter = kaltura.Filter().created_within_years(1).years_since_created(
3).page_size(10).max_iter(10)
sfilter = str(filter)
l = sum(1 for _ in filter)
self.assertEqual(
l, 0,
"expecting no videos created a year ago and created more than 3 years"
)
def play_info_creation_year(year):
f = kaltura.Filter().page_size(1000).years_since_created(
year - 1).created_wthin_years(year)
n = f.get_count()
f = f.tag(PLACE_HOLDER_VIDEO)
n_placeholder = f.get_count()
if (n > 0):
print "CREATED between CUR-{} - CUR-{} years: #videos: {} #place-holder {}".format(
year, year - 1, n, n_placeholder)
def year_status(year, sizes=False):
f = kaltura.Filter().page_size(1000).years_since_played(
year - 1).played_within_years(year)
n = f.get_count()
if (n > 0):
if (sizes):
totalTB = KB_2_TB(sum_sizes(f))
print "PLAYED between CUR-{} - CUR-{} years: #videos: {} total-size TB {}".format(
year, year - 1, n, totalTB)
else:
print "PLAYED between CUR-{} - CUR-{} years: #videos: {}".format(
year, year - 1, n)
return n
def test_filter_nothing(self):
filter = kaltura.Filter().page_size(10).max_iter(7)
sfilter = str(filter)
l = sum(1 for _ in filter)
self.assertEqual(l, 7)
def test_filter_status(self):
filter = kaltura.Filter().status("2,7")
sfilter = str(filter)
for e in filter:
self.assertTrue(e.getStatus().getValue() in ["2", "7"])
def test_filter_plays_lower_than(self):
n = 11
filter = kaltura.Filter().plays_lt(n).page_size(10).max_iter(7)
sfilter = str(filter)
for e in filter:
self.assertTrue(e.plays < n)
def test_filter_bad_entry_id(self):
filter = kaltura.Filter().entry_id(TestKaltura.TEST_ID_1 + "BAD")
sfilter = str(filter)
l = sum(1 for _ in filter)
self.assertEqual(l, 0)
def test_page_5_size_5_maxentry_7(self):
filter = kaltura.Filter().first_page(5).page_size(11).max_iter(7)
l = sum(1 for _ in filter)
self.assertEqual(l, 7)
def test_filter_unplayed_for(self):
filter = kaltura.Filter().years_since_played(1).page_size(10).max_iter(
10)
sfilter = str(filter)
l = sum(1 for _ in filter)
self.assertEqual(l, 10, "expecting 10 videos unplayed for 1 year")
def test_filter_bad_entry_id_get_count(self):
filter = kaltura.Filter().entry_id(TestKaltura.TEST_ID_1 + "BAD")
sfilter = str(filter)
self.assertEqual(filter.get_count(), 0)
def test_same_returns(self):
filter = kaltura.Filter().first_page(2).max_iter(1)
e1 = list(filter)
filter = kaltura.Filter().first_page(2).max_iter(1)
e2 = list(filter)
self.assertEqual(e1, e2)
def test_page_1_size_10_maxentry_2(self):
filter = kaltura.Filter().first_page(1).page_size(10).max_iter(2)
l = sum(1 for _ in filter)
self.assertEqual(l, 2)
def test_filter_not_tag(self):
filter = kaltura.Filter().tag("!archived_to_s3")
sfilter = str(filter)
for e in filter:
self.assertFalse('archived_to_s3' in e.tags.split(', '))
def test_filter_created_within(self):
filter = kaltura.Filter().created_within_years(3).page_size(
10).max_iter(10)
sfilter = str(filter)
l = sum(1 for _ in filter)
self.assertEqual(l, 10, "expecting 10 videos created within 3 years")
def test_filter_created_before(self):
filter = kaltura.Filter().years_since_created(1).page_size(
10).max_iter(10)
sfilter = str(filter)
l = sum(1 for _ in filter)
self.assertEqual(l, 10, "expecting 10 videos created more than 1 year")
