def download(request, video_id, language_code, filename, format,
version_number=None):
video = get_object_or_404(Video, video_id=video_id)
workflow = video.get_workflow()
user = _user_for_download_permissions(request)
if not workflow.user_can_view_video(user):
raise PermissionDenied()
language = video.subtitle_language(language_code)
if language is None:
raise PermissionDenied()
public_only = workflow.user_can_view_private_subtitles(user,
language_code)
version = language.version(public_only=not public_only,
version_number=version_number)
if not version:
raise Http404()
if not format in babelsubs.get_available_formats():
raise HttpResponseServerError("Format not found")
subs_text = babelsubs.to(version.get_subtitles(), format,
language=version.language_code)
# since this is a downlaod, we can afford not to escape tags, specially
# true since speaker change is denoted by '>>' and that would get entirely
# stripped out
response = HttpResponse(subs_text, mimetype="text/plain")
response['Content-Disposition'] = 'attachment'
return response
def clean_subtitles(self):
subtitles = self.cleaned_data['subtitles']
if subtitles.size > KB_SIZELIMIT * 1024:
raise forms.ValidationError(fmt(
_(u'File size should be less %(size)s kb'),
size=KB_SIZELIMIT))
parts = subtitles.name.split('.')
extension = parts[-1].lower()
if extension not in babelsubs.get_available_formats():
raise forms.ValidationError(
fmt(_(u'Incorrect format. '
u'Upload one of the following: %(formats)s.'),
formats=", ".join(babelsubs.get_available_formats())))
text = subtitles.read()
encoding = chardet.detect(text)['encoding']
if not encoding:
raise forms.ValidationError(_(u'Can not detect file encoding'))
try:
parser = babelsubs.parsers.discover(extension)
subtitle_set = parser('en', force_unicode(text, encoding))
except babelsubs.SubtitleParserError:
raise forms.ValidationError(_(u'Incorrect subtitles format'))
subtitles.seek(0)
return subtitles
def convert_subtitles(request):
# FIXME: front end needs to send the DFXP for the subs
data = {}
errors = None
if request.POST:
if 'subtitles' and 'format' and 'language_code' in request.POST:
subtitles = request.POST['subtitles']
format = request.POST['format']
available_formats = babelsubs.get_available_formats()
if format not in available_formats:
errors = {
"errors": {
'format':
'You must pass a suitable format. Available formats are %s'
% available_formats
}
}
subs = babelsubs.storage.SubtitleSet(
initial_data=subtitles,
language_code=request.POST.get('language_code'))
# When we have newly serialized subtitles, put a stringified version of them
# into this object. This object is what gets dumped into the textarea on the
# front-end. If there are errors, also dump to result (the error would be displayed
# to the user in the textarea.
converted = babelsubs.to(subs, format)
data['result'] = converted
else:
errors = {
"errors": {
'subtitles': 'You need to send subtitles back',
'format': 'You must pass a suitable format',
},
'result': "Something went wrong, we're terribly sorry."
}
else:
errors = {'result': "Must be a POST request"}
res = json.dumps(errors or data)
return HttpResponse(res, content_type='application/javascript')
def download(request,
video_id,
language_code,
filename,
format,
version_number=None):
video = get_object_or_404(Video, video_id=video_id)
language = video.subtitle_language(language_code)
if language is None:
raise Http404
team_video = video.get_team_video()
if team_video and not team_video.team.user_is_member(request.user):
# Non-members can only see public versions
version = language.version(public_only=True,
version_number=version_number)
else:
version = language.version(public_only=False,
version_number=version_number)
if not version:
raise Http404
if not format in babelsubs.get_available_formats():
raise HttpResponseServerError("Format not found")
subs_text = babelsubs.to(version.get_subtitles(),
format,
language=version.language_code)
# since this is a downlaod, we can afford not to escape tags, specially
# true since speaker change is denoted by '>>' and that would get entirely
# stripped out
response = HttpResponse(subs_text, mimetype="text/plain")
response['Content-Disposition'] = 'attachment'
return response
def clean_draft(self):
data = self.cleaned_data['draft']
if data.size > SUBTITLE_FILESIZE_LIMIT_KB * 1024:
raise forms.ValidationError(
fmt(_(u'File size must be less than %(size)s kb.'),
size=SUBTITLE_FILESIZE_LIMIT_KB))
parts = data.name.rsplit('.', 1)
self.extension = parts[-1].lower()
if self.extension not in babelsubs.get_available_formats():
raise forms.ValidationError(
fmt(_(u'Unsupported format. Please upload one of '
u'the following: %(formats)s'),
formats=", ".join(SUBTITLE_FILE_FORMATS)))
text = data.read()
encoding = chardet.detect(text)['encoding']
if not encoding:
raise forms.ValidationError(_(u'Can not detect file encoding'))
# For xml based formats we can't just convert to unicode, as the parser
# will complain that the string encoding doesn't match the encoding
# declaration in the xml file if it's not utf-8.
is_xml = self.extension in ('dfxp', 'ttml', 'xml')
decoded = force_unicode(text, encoding) if not is_xml else text
try:
# we don't know the language code yet, since we are early in the
# clean process. Set it to blank for now and we'll set it to the
# correct value in save()
self._parsed_subtitles = load_subtitles('', decoded,
self.extension)
except TypeError, e:
raise forms.ValidationError(e)
from django.utils.translation import ugettext_lazy as _
from apps.subtitles import pipeline
from apps.subtitles.shims import is_dependent
from apps.subtitles.models import ORIGIN_UPLOAD, SubtitleLanguage
from apps.teams.models import Task
from apps.teams.permissions import (
can_perform_task, can_create_and_edit_subtitles,
can_create_and_edit_translations
)
from apps.videos.tasks import video_changed_tasks
from utils.translation import get_language_choices, get_language_label
SUBTITLE_FILESIZE_LIMIT_KB = 512
SUBTITLE_FILE_FORMATS = babelsubs.get_available_formats()
class SubtitlesUploadForm(forms.Form):
draft = forms.FileField(required=True)
complete = forms.BooleanField(initial=False, required=False)
language_code = forms.ChoiceField(required=True,
choices=())
primary_audio_language_code = forms.ChoiceField(required=False,
choices=())
from_language_code = forms.ChoiceField(required=False,
choices=(),
initial='')
def __init__(self, user, video, allow_transcription=True, *args, **kwargs):
def test_available_formats(self):
actual_formats = sorted(get_available_formats())
expected_formats = sorted(['ass', 'srt', 'dfxp', 'ssa', 'sbv', 'txt', 'json', 'vtt', 'xml'])
self.assertEqual(actual_formats, expected_formats)
def download_subtitles(request, format):
video_id = request.GET.get('video_id')
lang_id = request.GET.get('lang_pk')
revision = request.GET.get('revision', None)
if not video_id:
#if video_id == None, Video.objects.get raise exception. Better show 404
#because video_id is required
raise Http404
video = get_object_or_404(models.Video, video_id=video_id)
if not lang_id:
# if no language is passed, assume it's the original one
language = video.subtitle_language()
if language is None:
raise Http404
else:
try:
language = video.newsubtitlelanguage_set.get(pk=lang_id)
except ObjectDoesNotExist:
raise Http404
team_video = video.get_team_video()
if not team_video:
# Non-team videos don't require moderation
version = language and language.version(public_only=False,
version_number=revision)
else:
# Members can see all versions
member = get_member(request.user, team_video.team)
if member:
version = language and language.version(public_only=False,
version_number=revision)
else:
version = language and language.version(version_number=revision)
if not version:
raise Http404
if not format in babelsubs.get_available_formats():
raise HttpResponseServerError("Format not found")
subs_text = babelsubs.to(version.get_subtitles(),
format,
language=version.language_code)
# since this is a downlaod, we can afford not to escape tags, specially true
# since speaker change is denoted by '>>' and that would get entirely stripped out
response = HttpResponse(subs_text, content_type="text/plain")
original_filename = '%s.%s' % (video.lang_filename(
language.language_code), format)
if not 'HTTP_USER_AGENT' in request.META or u'WebKit' in request.META[
'HTTP_USER_AGENT']:
# Safari 3.0 and Chrome 2.0 accepts UTF-8 encoded string directly.
filename_header = 'filename=%s' % original_filename.encode('utf-8')
elif u'MSIE' in request.META['HTTP_USER_AGENT']:
try:
original_filename.encode('ascii')
except UnicodeEncodeError:
original_filename = 'subtitles.' + format
filename_header = 'filename=%s' % original_filename
else:
# For others like Firefox, we follow RFC2231 (encoding extension in HTTP headers).
filename_header = 'filename*=UTF-8\'\'%s' % iri_to_uri(
original_filename.encode('utf-8'))
response['Content-Disposition'] = 'attachment; ' + filename_header
return response
def __init__(self, **kwargs):
kwargs['choices'] = babelsubs.get_available_formats()
super(SubFormatField, self).__init__(**kwargs)
def test_available_formats(self):
actual_formats = sorted(get_available_formats())
expected_formats = sorted(
['ass', 'srt', 'dfxp', 'ssa', 'sbv', 'txt', 'json', 'vtt', 'xml'])
self.assertEqual(actual_formats, expected_formats)
