def checkFormat(myFile, verbose): myFormat = "" if verbose: print "--- Checking subtitle format" capsFile = open(myFile) # open sub caps = capsFile.read() # read sub reader = detect_format(caps) # detect format with pycaption if verbose: print "--- pycaption says: %s" % reader if reader: if "srt" in str(reader): myFormat = "srt" elif "sami" in str(reader): myFormat = "sami" elif "dfxp" in str(reader): myFormat = "dfxp" else: if verbose: print "*** pycaption could not detect format" print "--- Checking if it's kanal5's own format..." if caps.startswith('[{"startMillis":'): if verbose: print "--- It probably is kanal5 format" myFormat = "kanal5" capsFile.close() # close sub return myFormat
def download(request, filename_hash, id, slug, extension): closedcaptions = get_object_or_404( ClosedCaptions, id=id, event__slug__iexact=slug, ) if extension not in FILE_EXTENSIONS.values(): raise http.Http404('Unrecognized extension') if closedcaptions.filename_hash != filename_hash: raise http.Http404('Unrecognized hash') for key, ext in FILE_EXTENSIONS.items(): if ext == extension: output_writer = SUPPORTED_WRITERS[key] content = closedcaptions.file.read() if not (closedcaptions.file.name.lower().endswith('.ttml') or closedcaptions.file.name.lower().endswith('.dfxp')): content = content.decode('utf-8') reader = pycaption.detect_format(content) assert reader converter = pycaption.CaptionConverter() converter.read(content, reader()) response = http.HttpResponse() response['Content-Type'] = CONTENT_TYPES.get(extension, 'text/plain') response.write(converter.write(output_writer())) return response
def download(request, filename_hash, id, slug, extension): closedcaptions = get_object_or_404( ClosedCaptions, id=id, event__slug__iexact=slug, ) if extension not in FILE_EXTENSIONS.values(): raise http.Http404('Unrecognized extension') if closedcaptions.filename_hash != filename_hash: raise http.Http404('Unrecognized hash') for key, ext in FILE_EXTENSIONS.items(): if ext == extension: output_writer = SUPPORTED_WRITERS[key] content = closedcaptions.file.read() if not ( closedcaptions.file.name.lower().endswith('.ttml') or closedcaptions.file.name.lower().endswith('.dfxp') ): content = content.decode('utf-8') reader = pycaption.detect_format(content) assert reader converter = pycaption.CaptionConverter() converter.read(content, reader()) response = http.HttpResponse() response['Content-Type'] = CONTENT_TYPES.get(extension, 'text/plain') response.write(converter.write(output_writer())) return response
def convert_subtitles(closedcaption): str_output = '' count = 0 for closedcaption_url, i in closedcaption: count = int(i) + 1 if closedcaption_url is not None: try: cc_content = common.smart_unicode( connection.getURL(closedcaption_url, connectiontype=0).replace(' 9137', '')) reader = detect_format(cc_content) if reader: str_output = common.smart_utf8(SRTWriter().write( reader().read(cc_content))) file = open( os.path.join(ustvpaths.DATAPATH, 'subtitle-%s.srt' % str(count)), 'w') file.write(str_output) str_output = '' file.close() else: print "Unknown sub type" except Exception, e: print "Exception with Subs: ", e
def middleware_convert_sub(response, **kwargs): data = response.stream.content.decode('utf8') reader = detect_format(data) if reader: data = WebVTTWriter().write(reader().read(data)) response.stream.content = data.encode('utf8') response.headers['content-type'] = 'text/vtt'
def select_subtitles_file(self, fn): if not os.path.isfile(fn): def f(): dialog = Gtk.MessageDialog(self.win, 0, Gtk.MessageType.ERROR, Gtk.ButtonsType.CLOSE, "File Not Found") dialog.format_secondary_text("Could not find subtitles file: %s" % fn) dialog.run() dialog.destroy() GLib.idle_add(f) return fn = os.path.abspath(fn) ext = fn.split('.')[-1] display_name = os.path.basename(fn) if ext=='vtt': with open(fn) as f: self.subtitles = f.read() else: with open(fn,'rb') as f: caps = f.read() try: caps = caps.decode() except UnicodeDecodeError: caps = caps.decode('latin-1') if caps.startswith('\ufeff'): # BOM caps = caps[1:] converter = pycaption.CaptionConverter() converter.read(caps, pycaption.detect_format(caps)()) self.subtitles = converter.write(pycaption.WebVTTWriter()) pos = len(self.subtitle_store) self.subtitle_store.append([display_name, pos-2, self.subtitles]) self.subtitle_combo.set_active(pos)
def convert_subtitles_to_srt(i: str, o: str): ext = os.path.splitext(i)[1] if ext == '.srt': import shutil shutil.copy(i, o) elif ext in ('.ttml', '.xml', '.dfxp', '.tt'): # TTML from media_management_scripts.support.ttml2srt import convert_to_srt convert_to_srt(i, o) else: # VTT, SCC, etc from pycaption import detect_format, SRTWriter subtitle_str = _read_file(i) reader = detect_format(subtitle_str) if reader: subtitle_str = SRTWriter().write(reader().read(subtitle_str)) with open(o, 'w') as file: file.write(subtitle_str) else: # Attempt to use FFMPEG from media_management_scripts.support.executables import ffmpeg from media_management_scripts.support.executables import execute_with_output args = [ ffmpeg(), '-loglevel', 'fatal', '-y', '-i', i, '-c:s', 'srt', o ] ret, output = execute_with_output(args) if ret != 0: raise Exception( 'Exception during subtitle conversion: {}'.format(output))
def gen_thumbnail(self): container = self.fn.lower().split(".")[-1] thumbnail_fn = None subtitle_ids = [] if container in ('aac', 'mp3', 'wav'): cmd = ['ffmpeg', '-i', self.fn, '-f', 'ffmetadata', '-'] else: thumbnail_fn = tempfile.mkstemp(suffix='.jpg', prefix='gnomecast_thumbnail_')[1] os.remove(thumbnail_fn) cmd = [ 'ffmpeg', '-y', '-i', self.fn, '-f', 'mjpeg', '-vframes', '1', '-ss', '27', '-vf', 'scale=600:-1', thumbnail_fn ] self.ffmpeg_desc = output = subprocess.check_output( cmd, stderr=subprocess.STDOUT) for line in output.decode().split('\n'): line = line.strip() if line.startswith('Duration:'): self.duration = parse_ffmpeg_time(line.split()[1].strip(',')) if line.startswith('Stream') and 'Subtitle' in line: id = line.split()[1].strip('#').replace(':', '.') id = id[:id.index('(')] subtitle_ids.append(id) print('subtitle_ids', subtitle_ids) def f(): if thumbnail_fn: self.thumbnail_image.set_from_file(thumbnail_fn) os.remove(thumbnail_fn) self.win.resize(1, 1) self.update_status() GLib.idle_add(f) new_subtitles = [] for subtitle_id in subtitle_ids: srt_fn = tempfile.mkstemp(suffix='.srt', prefix='gnomecast_subtitles_')[1] output = subprocess.check_output([ 'ffmpeg', '-y', '-i', self.fn, '-vn', '-an', '-codec:s:%s' % subtitle_id, 'srt', srt_fn ], stderr=subprocess.STDOUT) with open(srt_fn) as f: caps = f.read() print('caps', caps) converter = pycaption.CaptionConverter() converter.read(caps, pycaption.detect_format(caps)()) subtitles = converter.write(pycaption.WebVTTWriter()) new_subtitles.append((subtitle_id, subtitles)) os.remove(srt_fn) def f(): pos = len(self.subtitle_store) for id, subs in new_subtitles: self.subtitle_store.append([id, pos - 2, subs]) pos += 1 GLib.idle_add(f)
def loadSrt(filename): fileid = os.path.basename(filename).split('.')[0] with codecs.open(filename, 'r', 'utf-8') as srtfile: content = srtfile.read() reader = pycaption.detect_format(content) if reader: caps = reader().read(content) return fileid, caps
def Subtitleload(inputfile): wttcaps=io.open(inputfile,"r",encoding='utf-8').read() converter = pycaption.CaptionConverter() #Captionset object as intermediary reader = pycaption.detect_format(wttcaps) converter.read(wttcaps,reader()) srtcaps = io.open('youroutputfiledirectorygoeshere.srt', "w", encoding='utf-8') #Write converter object into srtcaps file srtcaps.write(converter.write(SRTWriter()))
def convert_file(input_captions, output_writer): reader = pycaption.detect_format(input_captions) if not reader: raise RuntimeError('Unrecognized format') converter = pycaption.CaptionConverter() converter.read(input_captions, reader()) return converter.write(output_writer)
def convert_subs_to_vtt(input_subs_path, output_vtt_path): with open(input_subs_path, 'r') as f: text = f.read().decode(utils.get_file_encoding(input_subs_path)) reader = detect_format(text) subs = reader().read(text) output_text = WebVTTWriter().write(subs) with open(output_vtt_path, 'w') as w: w.write(output_text)
def _webvtt(url, _data_path, _headers, **kwargs): r = Session().get(url, headers=_headers) data = r.content.decode('utf8') reader = detect_format(data) data = WebVTTWriter().write(reader().read(data)) with open(_data_path, 'wb') as f: f.write(data.encode('utf8')) return _data_path + '|content-type=text/vtt'
def middleware_convert_sub(response, **kwargs): data = response.stream.content.decode('utf8') reader = detect_format(data) if reader: data = WebVTTWriter().write(reader().read(data)) if ADDON_DEV: path = 'special://temp/convert_sub.middleware' real_path = xbmc.translatePath(path) with open(real_path, 'wb') as f: f.write(data.encode('utf8')) response.stream.content = data.encode('utf8') response.headers['content-type'] = 'text/vtt'
def clean_file(self): value = self.cleaned_data['file'] # it must be possible to read it with pycaption reader = pycaption.detect_format(value.read()) extension = value.name.lower().split('.')[-1] valid_extensions = ('sami', 'ttml', 'srt', 'dfxp', 'dfxp', 'vtt', 'scc') # It's important to also check the file extension because, # for example, if you pass in a .py file, it will be recognized # by the WebVTTReader reader. if not reader or extension not in valid_extensions: raise forms.ValidationError( 'Not a valid caption file that could be recognized') return value
def download_subtitle(url, destination): if not url: return False r = requests.get(url) if not r.ok: return False reader = detect_format(r.text) if not reader: return False srt = SRTWriter().write(reader().read(r.text)) if xbmcvfs.exists(destination): xbmcvfs.delete(destination) f = xbmcvfs.File(destination, 'w') f.write(srt.encode("utf-8")) f.close() return True
def clean_file(self): value = self.cleaned_data['file'] # it must be possible to read it with pycaption reader = pycaption.detect_format(value.read()) extension = value.name.lower().split('.')[-1] valid_extensions = ( 'sami', 'ttml', 'srt', 'dfxp', 'dfxp', 'vtt', 'scc' ) # It's important to also check the file extension because, # for example, if you pass in a .py file, it will be recognized # by the WebVTTReader reader. if not reader or extension not in valid_extensions: raise forms.ValidationError( 'Not a valid caption file that could be recognized' ) return value
def convert_caps_to_vtt(caps): """ Utility method to convert any supported transcripts into WebVTT format. Supported input formats: DFXP/TTML - SAMI - SCC - SRT - WebVTT. Arguments: caps (unicode): Raw transcripts. Returns: unicode: Transcripts converted into WebVTT format. """ if caps: reader = detect_format(caps) if reader: return WebVTTWriter().write(reader().read(caps)) return u''
def select_subtitles_file(self, fn): ext = fn.split('.')[-1] display_name = os.path.basename(fn) if ext == 'vtt': with open(fn) as f: self.subtitles = f.read() else: with open(fn) as f: caps = f.read() if caps.startswith('\ufeff'): # BOM caps = caps[1:] converter = pycaption.CaptionConverter() converter.read(caps, pycaption.detect_format(caps)()) self.subtitles = converter.write(pycaption.WebVTTWriter()) pos = len(self.subtitle_store) self.subtitle_store.append([display_name, pos - 2, self.subtitles]) self.subtitle_combo.set_active(pos)
def save_videojs(self, data, suffix=''): """ The saving handler. """ i18n_ = self.runtime.service(self, "i18n").ugettext self.display_name = data['display_name'] self.url = data['url'].strip() for language in self.languages.keys(): subtitle_text = data['subtitle_text_' + language].strip() if subtitle_text: reader = detect_format(subtitle_text) if reader: try: subtitle = WebVTTWriter().write( reader().read(subtitle_text)) except: return Response(json.dumps({ 'error': i18n_( "Error occurred while saving VTT subtitles for language %s" ) % language.upper() }), status=400, content_type='application/json', charset='utf8') h = HTMLParser() self.subtitles[language] = h.unescape(subtitle) self.create_subtitles_file(self.subtitles[language]) else: return Response(json.dumps({ 'error': i18n_( "Error occurred while saving VTT subtitles for language %s" ) % language.upper() }), status=400, content_type='application/json', charset='utf8') else: self.subtitles[language] = "" return {'result': 'success'}
def parse_subtitles(path): # print('parsing {}'.format(path)) caps = None if os.path.exists(path): with open(path, 'r', encoding='latin-1') as fp: content = fp.read().replace('<tt:', '<').replace('</tt:', '</') reader = detect_format(content) if reader: try: set = reader().read(content) caps = set.get_captions(set.get_languages()[0]) except Exception as ex: print('ERROR: {}'.format(ex)) return caps
def transform_old_subtitle_to_new_form_if_exist(self, modify=False): """ It is possible to modify self.subtitles only in studio_view and save_videojs functions, so in studio_view we only dynamically modify self.subtitles dict, but in studio_view pernamently. """ i18n_ = self.runtime.service(self, "i18n").ugettext subtitles = copy.deepcopy(self.subtitles) if (not 'pl' in self.subtitles ) and self.subtitle_url and self.subtitle_text: reader = detect_format(self.subtitle_text) if reader: try: subtitle = WebVTTWriter().write(reader().read( self.subtitle_text)) except: return Response(json.dumps({ 'error': i18n_( "Error occurred while saving VTT subtitles for language PL" ) }), status=400, content_type='application/json', charset='utf8') h = HTMLParser() subtitles['pl'] = h.unescape(subtitle) if modify: self.subtitles = subtitles self.subtitle_url = self.subtitle_text = "" else: return subtitles else: return Response(json.dumps({ 'error': i18n_( "Error occurred while saving VTT subtitles for language PL" ) }), status=400, content_type='application/json', charset='utf8') else: return subtitles
def convert_to_vtt(caps): """Convert subtitles to WebVTT format Note that if the subtitles are already in VTT format, nothing is done. Args: caps (str or unicode) Returns: caps (unicode): None if the format could not be detected. """ if isinstance(caps, str): caps = caps.decode('utf-8') caps = caps.strip(u"\ufeff").strip(u"\n").strip(u"\r") sub_reader = pycaption.detect_format(caps) if sub_reader is None: return None if sub_reader != pycaption.WebVTTReader: caps = pycaption.WebVTTWriter().write(sub_reader().read(caps)) return caps
def get_reader(captions, options): """Return caption reader.""" try: reader = pycaption.detect_format(captions) except IndexError: reader = None if reader is None: raise Exception('No caption format detected') reader_options = {'content': captions} if reader is pycaption.SCCReader: if options.offset: reader_options['offset'] = options.offset if options.lang: reader_options['lang'] = options.lang return reader, reader_options
def convert_subs(subtitle_path: Path): """Convert any valid subtitle file to srt subtitles for processing, using pycaption; then process them. Args: subtitle_path -- path of subtitles to convert Return True if successful, False otherwise. """ with open(subtitle_path, encoding='utf-8') as sub_file: subtitles = sub_file.read() subtitle_reader_class = pycaption.detect_format(subtitles) if not subtitle_reader_class: return False subtitle_reader = subtitle_reader_class() srt_subtitles = pycaption.SRTWriter().write(subtitle_reader.read(subtitles)) with open(subtitle_path.with_suffix('.srt'), 'w', encoding='utf-8') as sub_file: sub_file.write(srt_subtitles) srt_to_timestamps(subtitle_path.with_suffix('.srt')) return True
def convert_subtitles(closedcaption): str_output = '' count = 0 for closedcaption_url, i in closedcaption: count = int(i) + 1 if closedcaption_url is not None: try: cc_content = common.smart_unicode(connection.getURL(closedcaption_url, connectiontype = 0).replace(' 9137', '')) reader = detect_format(cc_content) if reader: str_output = common.smart_utf8(SRTWriter().write(reader().read(cc_content))) file = open(os.path.join(ustvpaths.DATAPATH, 'subtitle-%s.srt' % str(count)), 'w') file.write(str_output) str_output='' file.close() else: print "Unknown sub type" except Exception, e: print "Exception with Subs: ", e
def convert_to_vtt(path): """ Convert a subtitles file from any format (e.g: srt) to vtt. This is necessary for use with videojs, which supports only vtt subtitles. """ caps = open(path, 'rb').read() try: caps = caps.decode('utf8') except UnicodeDecodeError: # Attempt to read with custom encoding detected = chardet.detect(caps) caps = caps.decode(detected['encoding']) caps = caps.strip("\ufeff").strip("\n").strip("\r") sub_reader = pycaption.detect_format(caps) if sub_reader is None: return None if sub_reader != pycaption.WebVTTReader: read_caps = sub_reader().read(caps) caps = pycaption.WebVTTWriter().write(read_caps) return caps
def get_captions(url): """ Given a url to a caption file, return a list of captions in the file. """ res = requests.get(url) if res.status_code != 200: print('Error fetching "%s": HTTP response %d' % (url, res.status_code)) sys.exit(1) caps = res.text reader = pycaption.detect_format(caps) if not reader: print("Error: Could not determine caption format!") sys.exit(1) cap_set = reader().read(caps) langs = cap_set.get_languages() if len(langs) > 1: print("Error: too many languages in caption file: %s" % (", ".join(langs))) sys.exit(1) return cap_set.get_captions(langs[0])
def update_subtitles(self): subtitle_ids = [] cmd = ['ffprobe', '-i', self.fn] output = subprocess.check_output(cmd, stderr=subprocess.STDOUT) for line in output.decode().split('\n'): line = line.strip() if line.startswith('Stream') and 'Subtitle' in line: id = line.split()[1].strip('#').replace(':','.') id = id[:id.index('(')] subtitle_ids.append(id) print('subtitle_ids', subtitle_ids) new_subtitles = [] for subtitle_id in subtitle_ids: srt_fn = tempfile.mkstemp(suffix='.srt', prefix='gnomecast_subtitles_')[1] output = subprocess.check_output(['ffmpeg', '-y', '-i', self.fn, '-vn', '-an', '-codec:s:%s' % subtitle_id, 'srt', srt_fn], stderr=subprocess.STDOUT) with open(srt_fn) as f: caps = f.read() #print('caps', caps) converter = pycaption.CaptionConverter() converter.read(caps, pycaption.detect_format(caps)()) subtitles = converter.write(pycaption.WebVTTWriter()) new_subtitles.append((subtitle_id, subtitles)) os.remove(srt_fn) def f(): self.subtitle_store.clear() self.subtitle_store.append(["No subtitles.", -1, None]) self.subtitle_store.append(["Add subtitle file...", -2, None]) self.subtitle_combo.set_active(0) pos = len(self.subtitle_store) for id, subs in new_subtitles: self.subtitle_store.append([id, pos-2, subs]) pos += 1 GLib.idle_add(f) ext = self.fn.split('.')[-1] sexts = ['vtt', 'srt'] for sext in sexts: if os.path.isfile(self.fn[:-len(ext)] + sext): self.select_subtitles_file(self.fn[:-len(ext)] + sext) break
def save_videojs(self, data, suffix=''): """ The saving handler. """ self.display_name = data['display_name'] self.url = data['url'].strip() self.allow_download = True if data[ 'allow_download'] == "True" else False # Str to Bool translation self.source_text = data['source_text'] if not os.path.exists(settings.MEDIA_ROOT + 'subtitle/polish/'): os.makedirs(settings.MEDIA_ROOT + 'subtitle/polish/') self.subtitle_url = '' if data['subtitle_text']: reader = detect_format(data['subtitle_text']) if reader: subtitle = WebVTTWriter().write(reader().read( data['subtitle_text'])) filename = str(uuid.uuid4()) f = codecs.open( settings.MEDIA_ROOT + 'subtitle/polish/' + filename, 'w', 'utf-8') f.write(subtitle) f.close() self.subtitle_url = settings.MEDIA_URL + 'subtitle/polish/' + filename self.source_url = data['source_url'].strip() self.subtitle_text = data['subtitle_text'] self.start_time = ''.join( data['start_time'].split()) # Remove whitespace self.end_time = ''.join(data['end_time'].split()) # Remove whitespace return { 'result': 'success', }
def get_subtitles(self, captions): subtitles = [] for idx, caption in enumerate(captions): try: r = self._session.get(caption['file']) reader = detect_format(r.text) srt = SRTWriter().write(reader().read(r.text)) except: log.debug('Failed to parse subtitle: {}'.format( caption['file'])) else: srtfile = xbmc.translatePath( 'special://temp/curiosity{}.{}.srt'.format( idx, caption['code'])).decode('utf-8') with codecs.open(srtfile, "w", "utf-8") as f: f.write(srt) subtitles.append(srtfile) return subtitles
def get_captions(url): ''' Given a url to a caption file, return a list of captions in the file. ''' res = requests.get(url) if res.status_code != 200: print('Error fetching "%s": HTTP response %d' % (url, res.status_code)) sys.exit(1) caps = res.text reader = pycaption.detect_format(caps) if not reader: print('Error: Could not determine caption format!') sys.exit(1) cap_set = reader().read(caps) langs = cap_set.get_languages() if len(langs) > 1: print('Error: too many languages in caption file: %s' % (', '.join(langs))) sys.exit(1) return cap_set.get_captions(langs[0])
def upload_subtitle(public_video_id, subtitle_public_id, language_code, content): """ Convert subtitle to VTT and upload it. Args: public_video_id (str) subtitle_id (str) language_code (str) content (bytes) """ # Note: if this ever raises an exception, we should convert it to SubtitleInvalid content = content.decode('utf-8') # Convert to VTT, whatever the initial format content = content.strip("\ufeff\n\r") sub_reader = pycaption.detect_format(content) if sub_reader is None: raise exceptions.SubtitleInvalid("Could not detect subtitle format") if sub_reader != pycaption.WebVTTReader: content = pycaption.WebVTTWriter().write(sub_reader().read(content)) backend.get().upload_subtitle(public_video_id, subtitle_public_id, language_code, content)
def v2(): transcript_filename = '12022017 NBPY SCC.scc' transcript_pathname = os.path.join( self.show_dir, "assets", "transcripts", transcript_filename ) caps = open(transcript_pathname, encoding='iso-8859-1').read() reader = pycaption.detect_format(caps) transcript = reader().read(caps) language = transcript.get_languages()[0] # ['en-US'] lines = transcript.get_captions(language) cls = Cut_List.objects.filter( episode=episode, apply=True).order_by('sequence') # video_start = None ep_t_out_filename = os.path.join( self.show_dir, "transcripts", episode.slug + ".scc" ) # head 12022017\ North\ Bay\ Day\ 1.txt # 10:06:56:00 >> Hi, everyone! Welcome to transcript_start = datetime.datetime.strptime( "12022017 10:06:56", '%m%d%Y %H:%M:%S' ) with open(ep_t_out_filename,'w') as f: segs=[] for cl in cls: start = cl.get_start_wall() end = cl.get_end_wall() segs.append( (start,end) ) # wall time of the start of the first clip: # if video_start is None: # video_start = start """ loffset_ms = ( transcript_start - video_start ).total_seconds() * 1000 print( {start for l in transcript: if start <= l['timestamp'] <= end: offset = l['timestamp'] - video_start seconds = int(offset.total_seconds()) hms = seconds//3600, (seconds%3600)//60, seconds%60 hms = "{}:{}:{}".format(*hms) l = "{}: {}".format( hms, l['text']) f.write(l+'\n') """ pprint( segs ) for s,e in segs: # print("s: {}".format(s)) # print("e: {}".format(e)) # df='%Y-%m-%d %H:%M:%S' df="%H:%M:%S" print( "{} - {}".format ( s.strftime(df), e.strftime(df) ) )
def set_transcript_from_file(self): content = self.file.read() reader = pycaption.detect_format(content) converter = pycaption.CaptionConverter() converter.read(content, reader()) self.transcript = converter.write(JSONTranscriptWriter())
def event_closed_captions_submit(request, event_id, id): event = get_object_or_404(Event, id=event_id) closedcaptions = get_object_or_404(ClosedCaptions, event=event, id=id) # XXX This might change. Instead of using the same tag as the one # being used, we might use a custom one just for the transcription # service. submission, = VidlySubmission.objects.filter( event=event, tag=event.template_environment['tag']) if request.method == 'POST': form = forms.SubmitClosedCaptionsForm(request.POST) if form.is_valid(): file_format = form.cleaned_data['file_format'] base_url = get_base_url(request) public_url = base_url + reverse('closedcaptions:download', args=( closedcaptions.filename_hash, closedcaptions.id, event.slug, file_format, )) # Send it in vidly.update_media_closed_captions( submission.tag, submission.url, public_url, hd=submission.hd, notify_url=None # XXX improve this some day ) if not closedcaptions.submission_info: closedcaptions.submission_info = {} if not closedcaptions.submission_info.get('submissions'): closedcaptions.submission_info['submissions'] = [] closedcaptions.submission_info['submissions'].append({ 'tag': submission.tag, 'url': submission.url, 'public_url': public_url, 'hd': submission.hd, 'date': timezone.now().isoformat(), }) closedcaptions.save() messages.success( request, '{} submitted for Vid.ly transcoding'.format(public_url)) return redirect('manage:event_closed_captions', event.id) else: form = forms.SubmitClosedCaptionsForm() content = closedcaptions.file.read() reader = pycaption.detect_format(content) converter = pycaption.CaptionConverter() converter.read(content, reader()) last_caption = converter.write(LastTimestampWriter()) / 1000000 context = { 'form': form, 'event': closedcaptions.event, 'closedcaptions': closedcaptions, 'last_caption': last_caption, 'submission': submission, } return render(request, 'manage/event_closed_captions_submit.html', context)
def event_closed_captions_submit(request, event_id, id): event = get_object_or_404(Event, id=event_id) closedcaptions = get_object_or_404(ClosedCaptions, event=event, id=id) # XXX This might change. Instead of using the same tag as the one # being used, we might use a custom one just for the transcription # service. submission, = VidlySubmission.objects.filter( event=event, tag=event.template_environment['tag'] ) if request.method == 'POST': form = forms.SubmitClosedCaptionsForm(request.POST) if form.is_valid(): file_format = form.cleaned_data['file_format'] base_url = get_base_url(request) public_url = base_url + reverse( 'closedcaptions:download', args=( closedcaptions.filename_hash, closedcaptions.id, event.slug, file_format, ) ) # Send it in vidly.update_media_closed_captions( submission.tag, submission.url, public_url, hd=submission.hd, notify_url=None # XXX improve this some day ) if not closedcaptions.submission_info: closedcaptions.submission_info = {} if not closedcaptions.submission_info.get('submissions'): closedcaptions.submission_info['submissions'] = [] closedcaptions.submission_info['submissions'].append({ 'tag': submission.tag, 'url': submission.url, 'public_url': public_url, 'hd': submission.hd, 'date': timezone.now().isoformat(), }) closedcaptions.save() messages.success( request, '{} submitted for Vid.ly transcoding'.format( public_url ) ) return redirect('manage:event_closed_captions', event.id) else: form = forms.SubmitClosedCaptionsForm() content = closedcaptions.file.read() reader = pycaption.detect_format(content) converter = pycaption.CaptionConverter() converter.read(content, reader()) last_caption = converter.write(LastTimestampWriter()) / 1000000 context = { 'form': form, 'event': closedcaptions.event, 'closedcaptions': closedcaptions, 'last_caption': last_caption, 'submission': submission, } return render(request, 'manage/event_closed_captions_submit.html', context)