import io
from os import unlink
-from tempfile import NamedTemporaryFile
from django.db import models
from django.utils.translation import gettext_lazy as _
from django.template import Template, Context
+import requests
from apiclient import youtube_call
-from archive.settings import LICENSE, LICENSE_NAME
from .utils import (
concat_audio,
concat_videos,
get_duration,
get_framerate,
mux,
+ standardize_audio,
standardize_video,
video_from_image,
)
from .thumbnail import create_thumbnail
+YOUTUBE_TITLE_LIMIT = 100
+
+
class YouTube(models.Model):
+ name = models.CharField(max_length=255)
title_template = models.CharField(max_length=1024, blank=True)
description_template = models.TextField(blank=True)
category = models.IntegerField(null=True, blank=True, choices=[
outro_flac = models.FileField(upload_to='youtube/outro_flac', blank=True)
loop_card = models.FileField(upload_to='youtube/card', blank=True)
loop_video = models.FileField(upload_to='youtube/loop_video', blank=True)
- thumbnail_template = models.FileField(upload_to='youtube/thumbnail', blank=True)
- thumbnail_definition = models.TextField(blank=True)
privacy_status = models.CharField(max_length=16, choices=[
('public', _('public')),
('unlisted', _('unlisted')),
verbose_name = _("YouTube configuration")
verbose_name_plural = _("YouTube configurations")
+ def __str__(self):
+ return self.name
+
def get_context(self, audiobook):
return Context(dict(
audiobook=audiobook,
- LICENSE=LICENSE,
- LICENSE_NAME=LICENSE_NAME,
))
def get_description(self, audiobook):
return Template(self.description_template).render(self.get_context(audiobook))
def get_title(self, audiobook):
- return Template(self.title_template).render(self.get_context(audiobook))
+ return Template(self.title_template).render(self.get_context(audiobook))[:YOUTUBE_TITLE_LIMIT]
def get_data(self, audiobook):
return dict(
data = self.get_data(audiobook)
part = ",".join(data.keys())
- with open(path, "rb") as f:
- response = youtube_call(
- "POST",
- "https://www.googleapis.com/upload/youtube/v3/videos",
- params={'part': part},
- json=data,
- resumable_data=f.read(),
- )
+ response = youtube_call(
+ "POST",
+ "https://www.googleapis.com/upload/youtube/v3/videos",
+ params={'part': part},
+ json=data,
+ resumable_file_path=path,
+ )
data = response.json()
audiobook.youtube_id = data['id']
audiobook.save(update_fields=['youtube_id'])
"https://www.googleapis.com/youtube/v3/videos",
params={"part": part},
json=data
- )
+ )
- def prepare_file(self, input_path, output_path=None):
- audio = self.prepare_audio(input_path)
- duration = self.get_duration(input_path)
+ def prepare_file(self, input_paths, output_path=None):
+ audio = self.prepare_audio(input_paths)
+ duration = self.get_duration(input_paths)
video = self.prepare_video(duration)
output = mux([video, audio], output_path=output_path)
unlink(audio)
unlink(video)
return output
- def get_duration(self, input_path):
- d = get_duration(input_path)
+ def get_duration(self, input_paths):
+ d = 0
+ for input_path in input_paths:
+ d += get_duration(input_path)
if self.intro_flac:
d += get_duration(self.intro_flac.path)
if self.outro_flac:
d += get_duration(self.outro_flac.path)
return d
-
- def prepare_audio(self, input_path):
+
+ def prepare_audio(self, input_paths):
files = []
if self.intro_flac:
- files.append(self.intro_flac.path)
- files.append(input_path)
+ files.append(standardize_audio(self.intro_flac.path))
+ for input_path in input_paths:
+ files.append(standardize_audio(input_path, cache=False))
if self.outro_flac:
- files.append(self.outro_flac.path)
- return concat_audio(files)
-
+ files.append(standardize_audio(self.outro_flac.path))
+ output = concat_audio(files)
+ for d in files:
+ unlink(d)
+ return output
+
def prepare_video(self, duration):
concat = []
outro = []
def update_thumbnail(self, audiobook):
thumbnail = self.prepare_thumbnail(audiobook)
- response = youtube_call(
- "POST",
- "https://www.googleapis.com/upload/youtube/v3/thumbnails/set",
- params={'videoId': audiobook.youtube_id},
- data=thumbnail.getvalue(),
- )
+ if thumbnail is not None:
+ response = youtube_call(
+ "POST",
+ "https://www.googleapis.com/upload/youtube/v3/thumbnails/set",
+ params={'videoId': audiobook.youtube_id},
+ data=thumbnail.getvalue(),
+ )
def prepare_thumbnail(self, audiobook):
- img = create_thumbnail(
- self.thumbnail_template.path,
- self.thumbnail_definition,
- {
- "author": ', '.join((a['name'] for a in audiobook.book['authors'])),
- "title": audiobook.book['title'],
- },
- lambda name: Font.objects.get(name=name).truetype.path
- )
- buf = io.BytesIO()
- img.save(buf, format='PNG')
- return buf
-
+ for thumbnail_template in ThumbnailTemplate.objects.filter(is_active=True).order_by('order'):
+ if not thumbnail_template.is_for_audiobook(audiobook):
+ continue
+ thumbnail = thumbnail_template.generate(audiobook)
+ if thumbnail is not None:
+ return thumbnail
+
class Card(models.Model):
youtube = models.ForeignKey(YouTube, models.CASCADE)
def __str__(self):
return self.name
+
+
+class ThumbnailTemplate(models.Model):
+ youtube = models.ForeignKey(YouTube, models.CASCADE)
+ order = models.SmallIntegerField()
+ is_active = models.BooleanField()
+ background = models.FileField(upload_to='youtube/thumbnail')
+ definition = models.TextField()
+ authors = models.CharField(max_length=255, blank=True)
+ epochs = models.CharField(max_length=255, blank=True)
+ kinds = models.CharField(max_length=255, blank=True)
+ genres = models.CharField(max_length=255, blank=True)
+ collections = models.CharField(max_length=255, blank=True)
+
+ class Meta:
+ ordering = ('order', )
+
+ def generate(self, audiobook):
+ try:
+ title = audiobook.book['title']
+ if audiobook.book.get('parent'):
+ parent_title = audiobook.book['parent']['title']
+ if not title.startswith(parent_title):
+ title = ", ".join((parent_title, title))
+
+ img = create_thumbnail(
+ self.background.path,
+ self.definition,
+ {
+ "author": ', '.join((a['name'] for a in audiobook.book['authors'])),
+ "title": title,
+ "part": (audiobook.youtube_volume or audiobook.part_name).strip() if audiobook.youtube_volume_count > 1 else '',
+ },
+ lambda name: Font.objects.get(name=name).truetype.path
+ )
+ except Exception as e:
+ print(e)
+ return
+ else:
+ buf = io.BytesIO()
+ img.save(buf, format='PNG')
+ return buf
+
+ def is_for_audiobook(self, audiobook):
+ for category in 'authors', 'epochs', 'kinds', 'genres':
+ if getattr(self, category):
+ book_slugs = set([g['slug'] for g in audiobook.book[category]])
+ template_slugs = set([g.strip() for g in getattr(self, category).split(',')])
+ if not book_slugs.intersection(template_slugs):
+ return False
+
+ if self.collections:
+ template_collections = set([g.strip() for g in self.collections.split(',')])
+ in_any = False
+ for collection in template_collections:
+ apidata = requests.get(
+ f'https://wolnelektury.pl/api/collections/{collection}/'
+ ).json()
+ for book in apidata['books']:
+ if book['slug'] == audiobook.slug:
+ in_any = True
+ break
+ if in_any:
+ break
+ if not in_any:
+ return False
+
+ return True
fnp / audio.git / blobdiff