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)