from telemeta.views.core import *
+from telemeta.views.core import serve_media
from telemeta.views.epub import *
class CollectionView(object):
title = ugettext('Collection') + ' : ' + public_id + ' : ' + mess
description = ugettext('Please login or contact the website administator to get a private access.')
messages.error(request, title)
- return render(request, 'telemeta/messages.html', {'description' : description})
+ return render(request, 'telemeta/messages.html', {'description': description})
playlists = get_playlists_names(request)
last_revision = None
return render(request, template, {'collection': collection, 'playlists': playlists,
- 'items': items, 'related_media': related_media,
- 'parents': parents, 'last_revision': last_revision })
+ 'items': items, 'related_media': related_media,
+ 'parents': parents, 'last_revision': last_revision})
@method_decorator(permission_required('telemeta.change_mediacollection'))
def collection_edit(self, request, public_id, template='telemeta/collection_edit.html'):
else:
form = MediaCollectionForm(instance=collection)
- return render(request, template, {'collection': collection, "form": form,})
+ return render(request, template, {'collection': collection, "form": form, })
@method_decorator(permission_required('telemeta.add_mediacollection'))
def collection_add(self, request, template='telemeta/collection_add.html'):
else:
form = MediaCollectionForm(instance=collection)
- return render(request, template, {'collection': collection, "form": form,})
+ return render(request, template, {'collection': collection, "form": form, })
@method_decorator(permission_required('telemeta.add_mediacollection'))
def collection_copy(self, request, public_id, template='telemeta/collection_edit.html'):
collection = MediaCollection.objects.get(public_id=public_id)
form = MediaCollectionForm(instance=collection)
- return render(request, template, {'collection': collection, "form": form,})
+ return render(request, template, {'collection': collection, "form": form, })
def collection_playlist(self, request, public_id, template, mimetype):
try:
def related_media_collection_stream(self, request, public_id, media_id):
collection = MediaCollection.objects.get(public_id=public_id)
media = MediaCollectionRelated.objects.get(collection=collection, id=media_id)
- response = StreamingHttpResponse(stream_from_file(media.file.path), content_type=media.mime_type)
-# response['Content-Disposition'] = 'attachment'
+ response = serve_media(media.file.path, content_type=media.mime_type)
return response
def related_media_collection_download(self, request, public_id, media_id):
collection = MediaCollection.objects.get(public_id=public_id)
media = MediaCollectionRelated.objects.get(collection=collection, id=media_id)
- filename = media.file.path.split(os.sep)[-1]
- response = StreamingHttpResponse(stream_from_file(media.file.path), content_type=media.mime_type)
- response['Content-Disposition'] = 'attachment; ' + 'filename=' + filename
+ response = serve_media(media.file.path, content_type=media.mime_type)
return response
@method_decorator(permission_required('telemeta.change_mediacollection'))
else:
formset = MediaCollectionRelatedFormSet(instance=collection)
- return render(request, template, {'collection': collection, 'formset': formset,})
+ return render(request, template, {'collection': collection, 'formset': formset, })
class CollectionZipView(View):
response = StreamingHttpResponse(zip_file, content_type='application/zip')
response['Content-Disposition'] = "attachment; filename=%s.%s" % \
- (collection.code, 'zip')
+ (collection.code, 'zip')
return response
@method_decorator(login_required)
return super(CollectionEditView, self).forms_valid(form, inlines)
def get_success_url(self):
- return reverse_lazy('telemeta-collection-detail', kwargs={'public_id':self.code})
+ return reverse_lazy('telemeta-collection-detail', kwargs={'public_id': self.code})
def get_context_data(self, **kwargs):
context = super(CollectionEditView, self).get_context_data(**kwargs)
return super(CollectionAddView, self).forms_valid(form, inlines)
def get_success_url(self):
- return reverse_lazy('telemeta-collection-detail', kwargs={'public_id':self.object.code})
+ return reverse_lazy('telemeta-collection-detail', kwargs={'public_id': self.object.code})
@method_decorator(permission_required('telemeta.add_mediacollection'))
def dispatch(self, *args, **kwargs):
return super(CollectionCopyView, self).dispatch(*args, **kwargs)
-
class CollectionEpubView(BaseEpubMixin, View):
"Download collection data embedded in an EPUB3 file"
# -*- coding: utf-8 -*-
# Copyright (C) 2007-2010 Samalyse SARL
-# Copyright (C) 2010-2012 Parisson SARL
+# Copyright (C) 2010-2017 Parisson SARL
+# Copyright (C) 2010-2017 Guillaume Pellerin
+# Copyright (C) 2010-2017 Thomas Fillon
# This file is part of Telemeta.
# Authors: Olivier Guilyardi <olivier@samalyse.com>
# Guillaume Pellerin <yomguy@parisson.com>
+# Thomas Fillon <thomas@parisson.com>
import re
import os
from django.template import RequestContext, loader
from django import template
from django.http import HttpResponse, HttpResponseRedirect, StreamingHttpResponse
+from django.http import FileResponse
from django.http import Http404
from django.shortcuts import render_to_response, redirect, get_object_or_404
from django.views.generic import *
from django.contrib.sites.models import Site
from django.template.defaultfilters import slugify
+
from telemeta.models import *
-import telemeta.models
+
import telemeta.interop.oai as oai
from telemeta.interop.oaidatasource import TelemetaOAIDataSource
from telemeta.util.unaccent import unaccent
class FixedFileWrapper(FileWrapper):
+
def __iter__(self):
self.filelike.seek(0)
return self
+
def send_file(request, filename, content_type='image/jpeg'):
"""
Send a file through Django without loading the whole file into
response['Content-Length'] = os.path.getsize(filename)
return response
-def nginx_media_accel(request, filename):
- """Send a protected medie file through nginx with X-Accel-Redirect"""
+
+def serve_media(filename, content_type="", buffering=True):
+ if True:
+ return nginx_media_accel(filename, content_type=content_type,
+ buffering=buffering)
+ else:
+ pass
+ # response = StreamingHttpResponse(stream_from_file(media.file.path), content_type=media.mime_type)
+ # response['Content-Disposition'] = 'attachment; ' + 'filename=' + filename
+
+
+def nginx_media_accel(media_path, content_type="", buffering=True):
+ """Send a protected media file through nginx with X-Accel-Redirect"""
response = HttpResponse()
- url = settings.MEDIA_URL + filename
- # let nginx determine the correct content type
- response['Content-Type'] = ""
+ url = settings.MEDIA_URL + media_path
+ filename = os.path.basename(media_path)
+ response['Content-Disposition'] = "attachment; filename=%s" % (filename)
+ response['Content-Type'] = content_type
response['X-Accel-Redirect'] = url
+ if not buffering:
+ response['X-Accel-Buffering'] = 'no'
+
return response
-def render(request, template, data = None, mimetype = None):
+
+def render(request, template, data=None, mimetype=None):
return render_to_response(template, data, context_instance=RequestContext(request),
mimetype=mimetype)
+
def stream_from_processor(decoder, encoder, flag):
pipe = decoder | encoder
for chunk in pipe.stream():
flag.value = True
flag.save()
+
def stream_from_file(file):
chunk_size = 0x100000
f = open(file, 'r')
break
yield chunk
+
def get_item_access(item, user):
# Item access rules according to this workflow:
# https://docs.google.com/spreadsheet/ccc?key=0ArKCjajoOT-fdDhJSDZoaUhqdDJvVkY5U3BXUWpNT0E#gid=0
access = 'full'
elif item.collection.public_access != 'mixed':
- if user.is_authenticated() :
+ if user.is_authenticated():
if item.collection.public_access == 'metadata' and item.collection.auto_period_access:
access = 'full'
else:
access = item.collection.public_access
elif item.collection.public_access == 'mixed':
- if user.is_authenticated() :
+ if user.is_authenticated():
if item.public_access == 'metadata' and item.auto_period_access:
access = 'full'
else:
return access
+
def get_revisions(nb, user=None):
last_revisions = Revision.objects.order_by('-time')
if user:
revisions.append({'revision': revision, 'element': element})
return revisions
+
def get_playlists(request, user=None):
if not user:
user = request.user
element = mods[type].objects.get(id=resource.resource_id)
except:
element = None
- resources.append({'element': element, 'type': resource.resource_type, 'public_id': resource.public_id })
+ resources.append({'element': element, 'type': resource.resource_type, 'public_id': resource.public_id})
playlists.append({'playlist': playlist, 'resources': resources})
- #add by Killian Mary for sort playlist by title
+ # add by Killian Mary for sort playlist by title
playlists.sort(key=lambda x: x['playlist'].title)
return playlists
media.title = title.replace('\n', '').strip()
media.save()
+
def auto_code(collection):
items = collection.items.all()
suffixes = []
suffixes.append(suffix)
if suffixes:
- return collection.code + '_' + str(max(suffixes)+1)
+ return collection.code + '_' + str(max(suffixes) + 1)
else:
return collection.code + '_001'
def get_room(content_type=None, id=None, name=None):
rooms = jqchat.models.Room.objects.filter(content_type=content_type,
- object_id=id)
+ object_id=id)
if not rooms:
room = jqchat.models.Room.objects.create(content_type=content_type,
- object_id=id,
- name=name[:254])
+ object_id=id,
+ name=name[:254])
else:
room = rooms[0]
return room
# Authors: Olivier Guilyardi <olivier@samalyse.com>
# Guillaume Pellerin <yomguy@parisson.com>
-
from telemeta.views.core import *
+from telemeta.views.core import serve_media
+from telemeta.views.core import TelemetaBaseMixin
from telemeta.views.marker import *
import timeside.core
import timeside.server as ts
graphers = []
for grapher in self.graphers:
if grapher.id() == self.default_grapher_id:
- graphers.insert(0, {'name':grapher.name(), 'id': grapher.id()})
+ graphers.insert(0, {'name': grapher.name(), 'id': grapher.id()})
elif not hasattr(grapher, '_staging'):
- graphers.append({'name':grapher.name(), 'id': grapher.id()})
+ graphers.append({'name': grapher.name(), 'id': grapher.id()})
elif not grapher._staging:
- graphers.append({'name':grapher.name(), 'id': grapher.id()})
+ graphers.append({'name': grapher.name(), 'id': grapher.id()})
return graphers
def get_grapher(self, id):
for encoder in self.encoders:
if encoder.file_extension() in self.export_formats:
formats.append({'name': encoder.format(),
- 'extension': encoder.file_extension()})
+ 'extension': encoder.file_extension()})
return formats
def item_previous_next(self, item):
previous_pk = pks[-2]
next_pk = pks[0]
else:
- previous_pk = pks[pks.index(pk)-1]
- next_pk = pks[pks.index(pk)+1]
+ previous_pk = pks[pks.index(pk) - 1]
+ next_pk = pks[pks.index(pk) + 1]
for it in items:
if it.pk == previous_pk:
previous = it
previous = previous.public_id
next = next.public_id
else:
- previous = item.public_id
- next = item.public_id
+ previous = item.public_id
+ next = item.public_id
return previous, next
@jsonrpc_method('telemeta.get_item_export_url')
"""Provide Item web UI methods"""
def item_detail(self, request, public_id=None, marker_id=None, width=None, height=None,
- template='telemeta/mediaitem_detail.html'):
+ template='telemeta/mediaitem_detail.html'):
"""Show the details of a given item"""
# get item with one of its given marker_id
title = ugettext('Item') + ' : ' + public_id + ' : ' + mess
description = ugettext('Please login or contact the website administator to get a private access.')
messages.error(request, title)
- return render(request, 'telemeta/messages.html', {'description' : description})
+ return render(request, 'telemeta/messages.html', {'description': description})
previous, next = self.item_previous_next(item)
mime_type = item.mime_type
- if mime_type and mime_type != 'none' :
+ if mime_type and mime_type != 'none':
if 'quicktime' in mime_type:
mime_type = 'video/mp4'
format = item.format.get()
return render(request, template,
- {'item': item, 'export_formats': self.get_export_formats(),
- 'visualizers': self.get_graphers(), 'auto_zoom': self.auto_zoom,
- 'audio_export_enabled': self.export_enabled,
- 'previous' : previous, 'next' : next, 'marker': marker_id, 'playlists' : playlists,
- 'access': access, 'width': width, 'height': height,
- 'related_media': related_media, 'mime_type': mime_type, 'last_revision': last_revision,
- 'format': format,
- })
+ {'item': item, 'export_formats': self.get_export_formats(),
+ 'visualizers': self.get_graphers(), 'auto_zoom': self.auto_zoom,
+ 'audio_export_enabled': self.export_enabled,
+ 'previous': previous, 'next': next, 'marker': marker_id, 'playlists': playlists,
+ 'access': access, 'width': width, 'height': height,
+ 'related_media': related_media, 'mime_type': mime_type, 'last_revision': last_revision,
+ 'format': format,
+ })
def related_media_item_stream(self, request, item_public_id, media_id):
item = get_object_or_404(MediaItem, code=item_public_id)
media = get_object_or_404(MediaItemRelated, item=item, id=media_id)
if media.file:
- response = StreamingHttpResponse(stream_from_file(media.file.path), content_type=media.mime_type)
+ response = serve_media(media.file.path, content_type=media.mime_type)
else:
raise Http404
return response
item = get_object_or_404(MediaItem, code=item_public_id)
media = get_object_or_404(MediaItemRelated, item=item, id=media_id)
if media.file:
- filename = media.file.path.split(os.sep)[-1]
- response = StreamingHttpResponse(stream_from_file(media.file.path), content_type=media.mime_type)
- response['Content-Disposition'] = 'attachment; ' + 'filename=' + filename
+ response = serve_media(media.file.path, content_type=media.mime_type)
else:
raise Http404
return response
return redirect('telemeta-item-edit', public_id)
else:
formset = MediaItemRelatedFormSet(instance=item)
- return render(request, template, {'item': item, 'formset': formset,})
-
+ return render(request, template, {'item': item, 'formset': formset, })
@method_decorator(permission_required('telemeta.delete_mediaitem'))
def item_delete(self, request, public_id):
analyzers.append(analysis.to_dict())
mime_type = 'text/xml'
response = HttpResponse(self.cache_data.get_analyzer_xml(analyzers), content_type=mime_type)
- response['Content-Disposition'] = 'attachment; filename='+public_id+'.xml'
+ response['Content-Disposition'] = 'attachment; filename=' + public_id + '.xml'
return response
def item_visualize(self, request, public_id, grapher_id, width, height):
decoder = timeside.core.get_processor('file_decoder')(source)
graph = grapher(width=width, height=height)
(decoder | graph).run()
- graph.watermark('timeside', opacity=.6, margin=(5,5))
+ graph.watermark('timeside', opacity=.6, margin=(5, 5))
f = open(path, 'w')
graph.render(output=path)
f.close()
list = []
for encoder in self.encoders:
list.append(encoder.file_extension())
- #FIXME: MP4
+ # FIXME: MP4
list.append('mp4')
return list
public_access = get_item_access(item, request.user)
if (not public_access == 'full' or not extension in settings.TELEMETA_STREAMING_FORMATS) and \
- not (request.user.has_perm('telemeta.can_play_all_items') or request.user.is_superuser):
+ not (request.user.has_perm('telemeta.can_play_all_items') or request.user.is_superuser):
mess = ugettext('Access not allowed')
title = 'Item file : ' + public_id + '.' + extension + ' : ' + mess
description = ugettext('Please login or contact the website administator to get a private access.')
messages.error(request, title)
- return render(request, 'telemeta/messages.html', {'description' : description})
+ return render(request, 'telemeta/messages.html', {'description': description})
- #FIXME: MP4 handling in TimeSide
+ # FIXME: MP4 handling in TimeSide
if 'mp4' in extension:
mime_type = 'video/mp4'
video = item.file.path
- response = StreamingHttpResponse(stream_from_file(video), mimetype = mime_type)
- response['Content-Disposition'] = 'attachment'
+ response = serve_media(video, content_type=mime_type)
+ # response['Content-Disposition'] = 'attachment'
+ #Â TF : I don't know why empty attachment was set
+ # TODO: remove if useless
return response
if 'webm' in extension:
mime_type = 'video/webm'
video = item.file.path
- response = StreamingHttpResponse(stream_from_file(video), mimetype = mime_type)
- response['Content-Disposition'] = 'attachment'
+ response = serve_media(video, content_type=mime_type)
+ # response['Content-Disposition'] = 'attachment'
+ #Â TF : I don't know why empty attachment was set,
+ # TODO: remove if useless
return response
for encoder in self.encoders:
mime_type = encoder.mime_type()
file = public_id + '.' + encoder.file_extension()
- source, _ = item.get_source()
+ source, source_type = item.get_source()
flag = MediaItemTranscodingFlag.objects.filter(item=item, mime_type=mime_type)
if not flag:
mapping = DublinCoreToFormatMetadata(extension)
metadata = mapping.get_metadata(dc_metadata)
- if mime_type in format:
+ if mime_type in format and source_type == 'file':
# source > stream
if not extension in mapping.unavailable_extensions:
proc = encoder(source, overwrite=True)
proc.set_metadata(metadata)
try:
- #FIXME: should test if metadata writer is available
+ # FIXME: should test if metadata writer is available
proc.write_metadata()
except:
pass
- response = StreamingHttpResponse(stream_from_file(source), mimetype = mime_type)
+ response = serve_media(source, content_type=mime_type)
else:
media = self.cache_export.dir + os.sep + file
if not self.cache_export.exists(file) or not flag.value:
# source > encoder > stream
decoder = timeside.core.get_processor('file_decoder')(source)
- proc = encoder(media, streaming=True, overwrite=True)
+ proc = encoder(media, streaming=False, overwrite=True)
if extension in mapping.unavailable_extensions:
- metadata=None
+ metadata = None
proc.set_metadata(metadata)
self.cache_export.add_file(file)
+ pipe = decoder | proc
+ pipe.run()
+ flag.value = True
+ flag.save()
+ return HttpResponse('Plop')
response = StreamingHttpResponse(stream_from_processor(decoder, proc, flag), content_type=mime_type)
else:
# cache > stream
- response = StreamingHttpResponse(self.cache_export.read_stream_bin(file), content_type=mime_type)
- response['Content-Disposition'] = 'attachment'
+ response = serve_media(media, content_type=mime_type, buffering=False)
+
return response
def item_playlist(self, request, public_id, template, mimetype):
return redirect('telemeta-item-edit', item.public_id)
else:
formset = PerformanceFormSet(instance=item)
- return render(request, template, {'item': item, 'formset': formset,})
+ return render(request, template, {'item': item, 'formset': formset, })
@method_decorator(permission_required('telemeta.change_mediaitem'))
def item_keywords_edit(self, request, public_id, template):
return redirect('telemeta-item-edit', item.public_id)
else:
formset = FormSet(instance=item)
- return render(request, template, {'item': item, 'formset': formset,})
+ return render(request, template, {'item': item, 'formset': formset, })
class ItemListView(ListView):
context['results_page'] = int(self.request.GET.get('results_page', 20))
return context
+
class ItemListViewFullAccess(ListView):
model = MediaItem
template_name = "telemeta/mediaitem_list.html"
paginate_by = 20
- queryset = MediaItem.objects.enriched().filter(Q(collection__public_access="full")|Q(public_access="full")).sound().exclude(collection__public_access="none").order_by('code', 'old_code')
+ queryset = MediaItem.objects.enriched().filter(Q(collection__public_access="full") | Q(public_access="full")).sound().exclude(collection__public_access="none").order_by('code', 'old_code')
def get_context_data(self, **kwargs):
context = super(ItemListViewFullAccess, self).get_context_data(**kwargs)
queryset = MediaItem.objects.sound().order_by('code', 'old_code')
+
class ItemInstrumentListView(ItemListView):
template_name = "telemeta/media_item_instrument_list.html"
def get_context_data(self, **kwargs):
context = super(ItemInstrumentListView, self).get_context_data(**kwargs)
- context['nom']=Instrument.objects.get(id=self.kwargs['value_id']).name
- context['id']=self.kwargs['value_id']
+ context['nom'] = Instrument.objects.get(id=self.kwargs['value_id']).name
+ context['id'] = self.kwargs['value_id']
return context
+
class ItemInstrumentPublishedListView(ItemInstrumentListView):
def get_queryset(self):
return super(ItemInstrumentPublishedListView, self).get_queryset().filter(collection__code__contains='_E_').order_by('code', 'old_code')
+
class ItemInstrumentUnpublishedListView(ItemInstrumentListView):
def get_queryset(self):
return super(ItemInstrumentUnpublishedListView, self).get_queryset().filter(collection__code__contains='_I_').order_by('code', 'old_code')
+
class ItemInstrumentSoundListView(ItemInstrumentListView):
- def get_queryset(self):
+
+ def get_queryset(self):
return super(ItemInstrumentSoundListView, self).get_queryset().sound().order_by('code', 'old_code')
+
class ItemAliasListView(ItemListView):
template_name = "telemeta/media_item_alias_list.html"
def get_context_data(self, **kwargs):
context = super(ItemAliasListView, self).get_context_data(**kwargs)
- context['nom']=InstrumentAlias.objects.get(id=self.kwargs['value_id']).name
- context['id']=self.kwargs['value_id']
+ context['nom'] = InstrumentAlias.objects.get(id=self.kwargs['value_id']).name
+ context['id'] = self.kwargs['value_id']
return context
+
class ItemAliasPublishedListView(ItemAliasListView):
def get_queryset(self):
return super(ItemAliasPublishedListView, self).get_queryset().filter(collection__code__contains='_E_').order_by('code', 'old_code')
+
class ItemAliasUnpublishedListView(ItemAliasListView):
def get_queryset(self):
return super(ItemAliasUnpublishedListView, self).get_queryset().filter(collection__code__contains='_I_').order_by('code', 'old_code')
+
class ItemAliasSoundListView(ItemAliasListView):
- def get_queryset(self):
+
+ def get_queryset(self):
return super(ItemAliasSoundListView, self).get_queryset().sound().order_by('code', 'old_code')
+
class ItemViewMixin(ItemBaseMixin):
model = MediaItem
return super(ItemEditView, self).forms_valid(form, inlines)
def get_success_url(self):
- return reverse_lazy('telemeta-item-detail', kwargs={'public_id':self.code})
+ return reverse_lazy('telemeta-item-detail', kwargs={'public_id': self.code})
def get_context_data(self, **kwargs):
context = super(ItemEditView, self).get_context_data(**kwargs)
context['item'] = item
context['access'] = get_item_access(item, self.request.user)
context['previous'], context['next'] = self.item_previous_next(item)
- #FIXME
+ # FIXME
context['mime_type'] = 'audio/mp3'
context['export_formats'] = self.get_export_formats()
context['visualizers'] = self.get_graphers()
return super(ItemAddView, self).forms_valid(form, inlines)
def get_success_url(self):
- return reverse_lazy('telemeta-item-detail', kwargs={'public_id':self.object.code})
+ return reverse_lazy('telemeta-item-detail', kwargs={'public_id': self.object.code})
@method_decorator(permission_required('telemeta.add_mediaitem'))
def dispatch(self, *args, **kwargs):
return super(ItemCopyView, self).forms_valid(form, inlines)
def get_success_url(self):
- return reverse_lazy('telemeta-item-detail', kwargs={'public_id':self.object.code})
+ return reverse_lazy('telemeta-item-detail', kwargs={'public_id': self.object.code})
def get_context_data(self, **kwargs):
context = super(ItemCopyView, self).get_context_data(**kwargs)
context['item'] = item
context['access'] = get_item_access(item, self.request.user)
context['previous'], context['next'] = self.item_previous_next(item)
- #FIXME
+ # FIXME
context['mime_type'] = 'audio/mp3'
context['export_formats'] = self.get_export_formats()
context['visualizers'] = self.get_graphers()
height = size.split('x')[1]
image_file = '.'.join([item.public_id, self.default_grapher_id, size.replace('x', '_'), 'png'])
path = self.cache_data.dir + os.sep + image_file
- graph = default_grapher(width = int(width), height = int(height))
- graphers_sub.append({'graph' : graph, 'path': path})
+ graph = default_grapher(width=int(width), height=int(height))
+ graphers_sub.append({'graph': graph, 'path': path})
pipe = pipe | graph
pipe.run()
for grapher in graphers_sub:
- grapher['graph'].watermark('timeside', opacity=.6, margin=(5,5))
+ grapher['graph'].watermark('timeside', opacity=.6, margin=(5, 5))
f = open(grapher['path'], 'w')
grapher['graph'].render(grapher['path'])
f.close()
if os.path.exists(source):
mime_type = mimetypes.guess_type(source)[0]
analysis = MediaItemAnalysis(item=item, name='MIME type',
- analyzer_id='mime_type', unit='', value=mime_type)
+ analyzer_id='mime_type', unit='', value=mime_type)
analysis.save()
analysis = MediaItemAnalysis(item=item, name='Size',
- analyzer_id='size', unit='', value=item.size())
+ analyzer_id='size', unit='', value=item.size())
analysis.save()
analysis = MediaItemAnalysis(item=item, name='Channels',
analysis.save()
analysis = MediaItemAnalysis(item=item, name='Duration',
analyzer_id='duration', unit='s',
- value=unicode(datetime.timedelta(0,decoder.input_duration)))
+ value=unicode(datetime.timedelta(0, decoder.input_duration)))
analysis.save()
for analyzer in analyzers_sub:
if value.shape[0] == 1:
value = value[0]
analysis = MediaItemAnalysis(item=item, name=result.name,
- analyzer_id=result.id, unit=result.unit, value = unicode(value))
+ analyzer_id=result.id, unit=result.unit, value=unicode(value))
analysis.save()
# FIXME: parse tags on first load
self.item_analyze(item)
- #FIXME: use mimetypes.guess_type
+ # FIXME: use mimetypes.guess_type
if 'quicktime' in self.mime_type:
self.mime_type = 'video/mp4'
rang = []
for i in range(len(playlists)):
- for resource in playlists[i]['playlist'].resources.all():
- if int(resource.resource_id) == item.id:
- rang.append(i)
- break
+ for resource in playlists[i]['playlist'].resources.all():
+ if int(resource.resource_id) == item.id:
+ rang.append(i)
+ break
related_media = MediaItemRelated.objects.filter(item=item)
check_related_media(related_media)
revisions = Revision.objects.filter(element_type='item', element_id=item.id).order_by('-time')
context['format'] = item_format
context['private_extra_types'] = private_extra_types.values()
context['site'] = 'http://' + Site.objects.all()[0].name
- context['rang_item_playlist']=rang
+ context['rang_item_playlist'] = rang
# if ts_item:
# context['ts_item_id'] = ts_item.pk
# else:
"""a mapping class to get item DublinCore metadata dictionaries
in various audio metadata format (MP3, OGG, etc...)"""
- #FIXME: should be given by timeside
+ # FIXME: should be given by timeside
unavailable_extensions = ['wav', 'aiff', 'aif', 'flac', 'webm']
metadata_mapping = {
- 'mp3' : {
- 'title': 'TIT2', #title2
- 'creator': 'TCOM', #composer
- 'creator': 'TPE1', #lead
- 'identifier': 'UFID', #unique ID
- 'relation': 'TALB', #album
- 'type': 'TCON', #genre
- 'publisher': 'TPUB', #publisher
- 'date': 'TDRC', #year
-# 'coverage': 'COMM', #comment
- },
- 'ogg': {
- 'creator': 'artist',
- 'relation': 'album',
+ 'mp3': {
+ 'title': 'TIT2', # title2
+ 'creator': 'TCOM', # composer
+ 'creator': 'TPE1', # lead
+ 'identifier': 'UFID', # unique ID
+ 'relation': 'TALB', # album
+ 'type': 'TCON', # genre
+ 'publisher': 'TPUB', # publisher
+ 'date': 'TDRC', # year
+ # 'coverage': 'COMM', #comment
+ },
+ 'ogg': {
+ 'creator': 'artist',
+ 'relation': 'album',
'all': 'all',
- },
- 'flac': {
- 'creator': 'artist',
- 'relation': 'album',
+ },
+ 'flac': {
+ 'creator': 'artist',
+ 'relation': 'album',
'all': 'all',
- },
- 'wav': {
- 'creator': 'artist',
- 'relation': 'album',
+ },
+ 'wav': {
+ 'creator': 'artist',
+ 'relation': 'album',
'all': 'all',
- },
- 'webm': {
- 'creator': 'artist',
- 'relation': 'album',
+ },
+ 'webm': {
+ 'creator': 'artist',
+ 'relation': 'album',
'all': 'all',
- },
- }
+ },
+ }
def __init__(self, format):
self.format = format
if key == 'date':
value = value.split(';')[0].split('=')
if len(value) > 1:
- value = value[1]
+ value = value[1]
value = value.split('-')[0]
else:
value = value[0].split('-')[0]
data = ''
response = HttpResponse(data, content_type='application/json')
response['Content-Disposition'] = "attachment; filename=%s.%s" % \
- (item.code, 'json')
+ (item.code, 'json')
return response
from telemeta.views.core import *
-from telemeta.views.epub import *
+from telemeta.views.core import serve_media
+from telemeta.views.epub import BaseEpubMixin
from django.utils.translation import ugettext_lazy as _
"""Provide Resource web UI methods"""
types = {'corpus':
- {'model': MediaCorpus,
- 'form' : MediaCorpusForm,
- 'related': MediaCorpusRelated,
- 'parent': MediaFonds,
- },
- 'fonds':
- {'model': MediaFonds,
- 'form' : MediaFondsForm,
- 'related': MediaFondsRelated,
- 'parent': None,
- }
- }
+ {'model': MediaCorpus,
+ 'form': MediaCorpusForm,
+ 'related': MediaCorpusRelated,
+ 'parent': MediaFonds,
+ },
+ 'fonds':
+ {'model': MediaFonds,
+ 'form': MediaFondsForm,
+ 'related': MediaFondsRelated,
+ 'parent': None,
+ }
+ }
def setup(self, type):
self.model = self.types[type]['model']
parents = []
return render(request, template, {'resource': resource, 'type': type, 'children': children,
- 'related_media': related_media, 'parents': parents, 'playlists': playlists,
- 'last_revision': last_revision })
+ 'related_media': related_media, 'parents': parents, 'playlists': playlists,
+ 'last_revision': last_revision})
def edit(self, request, type, public_id, template='telemeta/resource_edit.html'):
self.setup(type)
return redirect('telemeta-resource-detail', self.type, code)
else:
form = self.form(instance=resource)
- return render(request, template, {'resource': resource, 'type': type, 'form': form,})
+ return render(request, template, {'resource': resource, 'type': type, 'form': form, })
def add(self, request, type, template='telemeta/resource_add.html'):
self.setup(type)
return redirect('telemeta-resource-detail', self.type, code)
else:
form = self.form(instance=resource)
- return render(request, template, {'resource': resource, 'type': type, 'form': form,})
+ return render(request, template, {'resource': resource, 'type': type, 'form': form, })
def copy(self, request, type, public_id, template='telemeta/resource_edit.html'):
self.setup(type)
else:
resource = self.model.objects.get(code=public_id)
form = self.form(instance=resource)
- return render(request, template, {'resource': resource, 'type': type, "form": form,})
+ return render(request, template, {'resource': resource, 'type': type, "form": form, })
def playlist(self, request, type, public_id, template, mimetype):
self.setup(type)
for revision in revisions:
revision.delete()
resource.delete()
- return HttpResponseRedirect('/archives/'+self.type+'/')
+ return HttpResponseRedirect('/archives/' + self.type + '/')
def related_stream(self, request, type, public_id, media_id):
self.setup(type)
resource = self.model.objects.get(code=public_id)
media = self.related.objects.get(resource=resource, id=media_id)
if media.file:
- response = StreamingHttpResponse(stream_from_file(media.file.path), content_type=media.mime_type)
+ response = serve_media(media.file.path, content_type=media.mime_type)
else:
raise Http404
return response
resource = self.model.objects.get(code=public_id)
media = self.related.objects.get(resource=resource, id=media_id)
if media.file:
- filename = media.file.path.split(os.sep)[-1]
- response = StreamingHttpResponse(stream_from_file(media.file.path), content_type=media.mime_type)
- response['Content-Disposition'] = 'attachment; ' + 'filename=' + filename
+ response = serve_media(media.file.path, content_type=media.mime_type)
else:
raise Http404
return response
class ResourceMixin(View):
types = {'corpus':
- {'model': MediaCorpus,
- 'form' : MediaCorpusForm,
- 'related': MediaCorpusRelated,
- 'parent': MediaFonds,
- 'inlines': [CorpusRelatedInline,]
- },
- 'fonds':
- {'model': MediaFonds,
- 'form' : MediaFondsForm,
- 'related': MediaFondsRelated,
- 'parent': None,
- 'inlines': [FondsRelatedInline,]
- }
- }
+ {'model': MediaCorpus,
+ 'form': MediaCorpusForm,
+ 'related': MediaCorpusRelated,
+ 'parent': MediaFonds,
+ 'inlines': [CorpusRelatedInline, ]
+ },
+ 'fonds':
+ {'model': MediaFonds,
+ 'form': MediaFondsForm,
+ 'related': MediaFondsRelated,
+ 'parent': None,
+ 'inlines': [FondsRelatedInline, ]
+ }
+ }
def setup(self, type):
self.model = self.types[type]['model']
else:
context['parents'] = []
return context
-
+
class ResourceListView(ResourceMixin, ListView):
return self
def get_success_url(self):
- return reverse_lazy('telemeta-resource-list', kwargs={'type':self.kwargs['type']})
+ return reverse_lazy('telemeta-resource-list', kwargs={'type': self.kwargs['type']})
@method_decorator(permission_required('telemeta.add_mediacorpus'))
@method_decorator(permission_required('telemeta.add_mediafonds'))
return model_to_dict(self.get_object())
def get_success_url(self):
- return reverse_lazy('telemeta-resource-list', kwargs={'type':self.kwargs['type']})
+ return reverse_lazy('telemeta-resource-list', kwargs={'type': self.kwargs['type']})
# return reverse_lazy('telemeta-resource-detail', kwargs={'type':self.kwargs['type'], 'public_id':self.kwargs['public_id']})
@method_decorator(permission_required('telemeta.add_mediacorpus'))
template_name = 'telemeta/resource_confirm_delete.html'
def get_success_url(self):
- return reverse_lazy('telemeta-resource-list', kwargs={'type':self.kwargs['type']})
+ return reverse_lazy('telemeta-resource-list', kwargs={'type': self.kwargs['type']})
@method_decorator(permission_required('telemeta.delete_mediacorpus'))
@method_decorator(permission_required('telemeta.delete_mediafonds'))
template_name = 'telemeta/resource_edit.html'
def get_success_url(self):
- return reverse_lazy('telemeta-resource-detail', kwargs={'type':self.kwargs['type'], 'public_id':self.kwargs['public_id']})
+ return reverse_lazy('telemeta-resource-detail', kwargs={'type': self.kwargs['type'], 'public_id': self.kwargs['public_id']})
@method_decorator(permission_required('telemeta.change_mediacorpus'))
@method_decorator(permission_required('telemeta.change_mediafonds'))
projects / telemeta.git / commitdiff