def forwards(self, orm):
"Write your forwards methods here."
for missing_set_version in chunkediter(orm['subtitles.SubtitleVersion'].objects.filter(serialized_subtitles='')):
subtitles = SubtitleSet(missing_set_version.language_code)
missing_set_version.serialized_subtitles = compress(subtitles.to_xml())
missing_set_version.subtitle_count = 0
missing_set_version.save()
def _create_two_sub_forked_subs(self, request):
session = create_two_sub_dependent_session(request)
# now fork subtitles
response = rpc.start_editing(
request, session.video.video_id, 'es',
subtitle_language_pk=session.video.subtitle_language('es').pk)
session_pk = response['session_pk']
subtitle_set = SubtitleSet('es')
subtitle_set.append_subtitle(500, 1500, 'hey')
subtitle_set.append_subtitle(1600, 2500, 'you')
rpc.finished_subtitles(request, session_pk, subtitle_set.to_xml(), forked=True)
return Video.objects.get(pk=session.video.pk)
def test_log_in_then_save(self):
request_0 = RequestMockup(NotAuthenticatedUser())
return_value = rpc.show_widget(request_0, VIDEO_URL, False)
video_id = return_value['video_id']
return_value = rpc.start_editing(
request_0, video_id, 'en', original_language_code='en')
session_pk = return_value['session_pk']
sset = SubtitleSet('en')
sset.append_subtitle(2300, 3400, 'hey')
response = rpc.regain_lock(request_0, session_pk)
self.assertEqual('ok', response['response'])
request_0.user = self.user_0
rpc.finished_subtitles(request_0, session_pk, sset.to_xml())
sversion = sub_models.SubtitleVersion.objects.order_by('-pk')[0]
sversion.subtitle_count = 1
self.assertEqual(request_0.user.pk, sversion.author.pk)
def test_fork_translation_dependent_on_forked(self):
request = RequestMockup(self.user_0)
video = self._create_two_sub_forked_subs(request)
response = rpc.start_editing(request, video.video_id, 'fr', base_language_code='es')
session_pk = response['session_pk']
rpc.finished_subtitles(request, session_pk, create_subtitle_set(2).to_xml())
fr_sl = models.Video.objects.get(video_id=video.video_id).subtitle_language('fr')
self.assertEquals(False, fr_sl.is_forked)
# now fork french
return_value = rpc.show_widget(request, VIDEO_URL, False)
video_id = return_value['video_id']
fr_sl = models.Video.objects.get(video_id=video_id).subtitle_language('fr')
response = rpc.start_editing(request, video_id, 'fr', subtitle_language_pk=fr_sl.pk)
session_pk = response['session_pk']
subtitles = SubtitleSet('fr', response['subtitles']['subtitles'])
self.assertEquals(3, len(subtitles))
self.assertEquals('hey you 0', subtitles[0].text)
self.assertEquals(0, subtitles[0].start_time)
self.assertEquals(1000, subtitles[0].end_time)
# update the timing on the French sub.
updated = SubtitleSet('fr')
updated.append_subtitle(1020, 1500, 'hey 0')
updated.append_subtitle(2500, 3500, 'hey 1')
rpc.finished_subtitles(request, session_pk, updated.to_xml(), forked=True)
french_lang = models.Video.objects.get(video_id=video_id).subtitle_language('fr')
fr_version = french_lang.get_tip()
fr_version_subtitles = fr_version.get_subtitles()
self.assertTrue(french_lang.is_forked)
self.assertEquals(1020, fr_version_subtitles[0].start_time)
spanish_lang = models.Video.objects.get(video_id=video_id).subtitle_language('es')
es_version = spanish_lang.get_tip()
es_version_subtitles = es_version.get_subtitles()
self.assertEquals(True, spanish_lang.is_forked)
self.assertEquals(500, es_version_subtitles[0].start_time)
class TestFormatConvertion(TestCase):
def setUp(self):
self.subs = SubtitleSet(language_code='en')
for x in range(0,10):
self.subs.append_subtitle(
from_ms=(x * 1000), to_ms=(x * 1000) + 1000,
content="%s - and *italics* and **bold** and >>." % x
)
def _retrieve(self, format):
res = self.client.post(reverse("widget:convert_subtitles"), {
'subtitles': self.subs.to_xml(),
'language_code': 'pt-br',
'format': format,
})
self.assertEqual(res.status_code , 200)
data = json.loads(res.content)
self.assertNotIn('errors', data)
parser = babelsubs.load_from(data['result'], format).to_internal()
parsed = [x for x in parser.subtitle_items()]
self.assertEqual(len(parsed), 10)
return res.content, parsed
def test_srt(self):
raw, parsed = self._retrieve('srt')
self.assertEqual(parsed[1], (1000, 2000, '1 - and *italics* and **bold** and >>.', {'new_paragraph': False}))
def test_ssa(self):
raw, parsed = self._retrieve('ssa')
self.assertEqual(parsed[1], (1000, 2000, '1 - and *italics* and **bold** and >>.', {'new_paragraph': False}))
def test_dfxp(self):
raw, parsed = self._retrieve('dfxp')
self.assertEqual(parsed[1], (1000, 2000, '1 - and *italics* and **bold** and >>.', {'new_paragraph': False}))
def test_sbv(self):
raw, parsed = self._retrieve('sbv')
self.assertEqual(parsed[1], (1000, 2000, '1 - and *italics* and **bold** and >>.', {'new_paragraph': False}))
def test_change_set(self):
request = RequestMockup(self.user_0)
session = create_two_sub_session(request)
return_value = rpc.start_editing(request, session.video.video_id, 'en')
session_pk = return_value['session_pk']
subtitle_set = SubtitleSet('en')
subtitle_set.append_subtitle(0, 1000, 'hey you 3')
subtitle_set.append_subtitle(1000, 2000, 'hey you 1')
subtitle_set.append_subtitle(2000, 3000, 'hey you 1')
rpc.finished_subtitles(request, session_pk, subtitle_set.to_xml())
video = Video.objects.get(pk=session.video.pk)
language = video.subtitle_language('en')
self.assertEqual(2, language.subtitleversion_set.full().count())
version = language.get_tip()
time_change, text_change = version.get_changes()
self.assertTrue(text_change > 0 and text_change <= 1)
self.assertEqual(time_change, 0)
