def test_fetch_subs(self):
self.mock_captions_list.return_value = [
('caption-1', 'en', 'English'),
('caption-2', 'fr', 'French'),
]
en_subs = storage.SubtitleSet('en')
en_subs.append_subtitle(100, 200, 'text')
fr_subs = storage.SubtitleSet('fr')
fr_subs.append_subtitle(100, 200, 'french text')
def captions_download(access_token, video_id, language_code):
if language_code == 'en':
return en_subs.to_xml()
elif language_code == 'fr':
return fr_subs.to_xml()
else:
raise ValueError(language_code)
self.mock_captions_download.side_effect = captions_download
fetch_subs(self.video_url)
# check that we called the correct API methods
assert_equal(self.mock_get_new_access_token.call_args,
mock.call(self.account.oauth_refresh_token))
assert_equal(self.mock_captions_list.call_args,
mock.call('test-access-token', self.video_id))
assert_equal(self.mock_captions_download.call_args_list, [
mock.call('test-access-token', self.video_id, 'en'),
mock.call('test-access-token', self.video_id, 'fr'),
])
# check that we created the correct languages
assert_equal(
set(l.language_code for l in self.video.all_subtitle_languages()),
set(['en', 'fr']))
lang_en = self.video.subtitle_language('en')
lang_fr = self.video.subtitle_language('fr')
# check subtitle data
assert_equal(lang_en.get_tip().get_subtitles().to_xml(),
en_subs.to_xml())
assert_equal(lang_fr.get_tip().get_subtitles().to_xml(),
fr_subs.to_xml())
# check additional data
assert_equal(lang_en.subtitles_complete, True)
assert_equal(lang_fr.subtitles_complete, True)
assert_equal(lang_en.get_tip().origin, ORIGIN_IMPORTED)
assert_equal(lang_fr.get_tip().origin, ORIGIN_IMPORTED)
assert_equal(lang_en.get_tip().note, "From youtube")
assert_equal(lang_fr.get_tip().note, "From youtube")
def test_generate_centiseconds(self):
sset = storage.SubtitleSet('en')
sset.append_subtitle(133, 238,'hey')
output = unicode(SSAGenerator(sset))
# make sure time is 230 milliseconds not 38 and that
# we are rounding to 0.24 (instead of truncating to 0.23
self.assertIn("Dialogue: 0,0:00:00.13,0:00:00.24", output)
def test_escaping(self):
dfxp = storage.SubtitleSet('en')
dfxp.append_subtitle(0, 1000, "Hey <a>html anchor</a>", escape=False)
dfxp.append_subtitle(0, 1000, "Hey <a>html anchor</a>", escape=True)
self.assertEqual(storage.get_contents(dfxp.get_subtitles()[0]),
'Hey html anchor')
self.assertEqual(storage.get_contents(dfxp.get_subtitles()[1]),
'Hey <a>html anchor</a>')
def test_normalize_time(self):
content_str = open(utils.get_data_file_path("normalize-time.dfxp") ).read()
dfxp = storage.SubtitleSet('en', content_str, normalize_time=True)
subs = dfxp.get_subtitles()
self.assertTrue(len(dfxp) )
for el in subs:
self.assertIn("begin", el.attrib)
self.assertTrue(storage.TIME_EXPRESSION_CLOCK_TIME.match(el.attrib['begin']))
self.assertIn("end", el.attrib)
self.assertTrue(storage.TIME_EXPRESSION_CLOCK_TIME.match(el.attrib['end']))
self.assertNotIn('dur', el.attrib)
def test_no_timing(self):
dfxp = storage.SubtitleSet('en')
dfxp.append_subtitle(0, 1000, "paragraph 1 - A")
dfxp.append_subtitle(2000, None, "paragraph 1 - B")
dfxp.append_subtitle(None, None, "paragraph 1 - C")
items = [x for x in dfxp.subtitle_items()]
self.assertEquals(len(items), 3)
self.assertEquals(items[0][0], 0)
self.assertEquals(items[0][1], 1000)
self.assertEquals(items[1][0], 2000)
self.assertEquals(items[1][1], None)
self.assertEquals(items[2][0], None)
self.assertEquals(items[2][1], None)
self.assertFalse(dfxp.fully_synced)
dfxp = storage.SubtitleSet('en')
dfxp.append_subtitle(0, 1000, "paragraph 1 - A")
dfxp.append_subtitle(1000, 2000, "paragraph 1 - B")
dfxp.append_subtitle(2000, 3000, "paragraph 2 - A", new_paragraph=True)
dfxp.append_subtitle(3000, 4000, "paragraph 2 - B")
dfxp.append_subtitle(3000, 4000, "paragraph 2 - C")
self.assertTrue(dfxp.fully_synced)
def test_unsynced_generator(self):
subs = storage.SubtitleSet('en')
for x in xrange(0,5):
subs.append_subtitle(None, None,"%s" % x)
output = unicode(SSAGenerator(subs))
parsed = SSAParser(output,'en')
internal = parsed.to_internal()
subs = [x for x in internal.subtitle_items()]
self.assertEqual(len(internal), 5)
for i,sub in enumerate(subs):
self.assertEqual(sub[0], None )
self.assertEqual(sub[1], None )
generated = SSAGenerator(internal)
self.assertEqual(generated.format_time(None), u'9:59:59.99')
self.assertIn(u'Dialogue: 0,9:59:59.99,9:59:59.99,Default,,0000,0000,0000,,2', unicode(generated))
def test_fetch_subs_handles_bcp47_codes(self):
# youtube uses BCP-47 language codes. Ensure that we use this code
# when talking to youtube, but our own internal codes when storing
# subtitles.
self.mock_captions_list.return_value = [
('caption-1', 'pt-BR', 'Brazilian Portuguese'),
]
subs = storage.SubtitleSet('pt-br')
subs.append_subtitle(100, 200, 'text')
self.mock_captions_download.return_value = subs.to_xml()
fetch_subs(self.video_url, user=self.user)
assert_equal(self.mock_captions_download.call_args,
mock.call('test-access-token', 'caption-1'))
assert_equal(
[l.language_code for l in self.video.all_subtitle_languages()],
['pt-br'])
def test_new_paragraph(self):
dfxp = storage.SubtitleSet('en')
# first sub is always a paragraph break ;)
dfxp.append_subtitle(0, 1000, "paragraph 1 - A")
dfxp.append_subtitle(1000, 2000, "paragraph 1 - B")
dfxp.append_subtitle(2000, 3000, "paragraph 2 - A", new_paragraph=True)
dfxp.append_subtitle(3000, 4000, "paragraph 2 - B", new_paragraph=False)
dfxp.append_subtitle(3000, 4000, "paragraph 2 - C")
divs = dfxp._ttml.xpath('/n:tt/n:body/n:div', namespaces={'n': storage.TTML_NAMESPACE_URI})
self.assertEquals(len(divs), 2)
self.assertEquals(len(self._paragraphs_in_div(divs[0])), 2)
self.assertEquals(len(self._paragraphs_in_div(divs[1])), 3)
sub_lines = dfxp.subtitle_items()
# make sure subtitle items returns the right metadata
self.assertTrue(sub_lines[0].meta['new_paragraph'])
self.assertFalse(sub_lines[1].meta['new_paragraph'])
self.assertTrue(sub_lines[2].meta['new_paragraph'])
self.assertFalse(sub_lines[3].meta['new_paragraph'])
def test_timing_generator(self):
sset = storage.SubtitleSet('en')
sset.append_subtitle(40, 2930,"We started Universal Subtitles because we believe")
generated = unicode(SSAGenerator(sset))
self.assertIn('Dialogue: 0,0:00:00.04,0:00:02.93,Default,,0000,0000,0000,,We started Universal Subtitles because we believe', generated)
def test_newlines(self):
subs = storage.SubtitleSet('en')
subs.append_subtitle(0, 1000, "line1<br/>line2", escape=False)
items = subs.subtitle_items(mappings=SSAGenerator.MAPPINGS)
self.assertEqual(items[0].text, "line1\Nline2")
def test_region(self):
subs = storage.SubtitleSet('en')
subs.append_subtitle(0, 1000, "test", region="top")
elt = subs.get_subtitles()[0]
self.assertEqual(elt.attrib['region'], 'top')