fnp / audio.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
fix
[audio.git] / src / youtube / models.py
diff --git a/src/youtube/models.py b/src/youtube/models.py
index 423f338..39a1d2d 100644 (file)
--- a/src/youtube/models.py
+++ b/src/youtube/models.py
@@ -1,3 +1,4 @@
+import io
 from os import unlink
 from tempfile import NamedTemporaryFile
 from django.db import models
 from os import unlink
 from tempfile import NamedTemporaryFile
 from django.db import models
@@ -5,119 +6,210 @@ from django.utils.translation import gettext_lazy as _
 from django.template import Template, Context
 from apiclient import youtube_call
 from .utils import (
 from django.template import Template, Context
 from apiclient import youtube_call
 from .utils import (
-    video_from_image,
-    cut_video,
+    concat_audio,
     concat_videos,
     concat_videos,
+    cut_video,
     get_duration,
     get_framerate,
     mux,
     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):
     title_template = models.CharField(max_length=1024, blank=True)
     description_template = models.TextField(blank=True)
 
 
 class YouTube(models.Model):
     title_template = models.CharField(max_length=1024, blank=True)
     description_template = models.TextField(blank=True)
-    category = models.IntegerField(null=True, blank=True)  # get categories
-    intro_card = models.FileField(blank=True)
-    intro_card_duration = models.FloatField(null=True, blank=True)
-    card = models.FileField(blank=True)
-    loop_video = models.FileField(blank=True)
-    outro_card = models.FileField(blank=True)
-    outro_card_duration = models.FloatField(null=True, blank=True)
+    category = models.IntegerField(null=True, blank=True, choices=[
+        (27, 'Edukacja'),
+    ])
+    intro_flac = models.FileField(upload_to='youtube/intro_flac', blank=True)
+    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')),
+        ('private', _('private')),
+    ])
+    genres = models.CharField(max_length=2048, blank=True)
 
     class Meta:
         verbose_name = _("YouTube configuration")
         verbose_name_plural = _("YouTube configurations")
 
 
     class Meta:
         verbose_name = _("YouTube configuration")
         verbose_name_plural = _("YouTube configurations")
 
-    def publish(self, audiobook, path):
-        ctx = Context(dict(audiobook=audiobook))
-        description = Template(self.description_template).render(ctx)
-        title = Template(self.title_template).render(ctx)
-        privacy = 'private'
+    def get_context(self, audiobook):
+        return Context(dict(
+            audiobook=audiobook,
+        ))
+
+    def get_description(self, audiobook):
+        return Template(self.description_template).render(self.get_context(audiobook))
 
 
-        data = dict(
+    def get_title(self, audiobook):
+        return Template(self.title_template).render(self.get_context(audiobook))[:YOUTUBE_TITLE_LIMIT]
+
+    def get_data(self, audiobook):
+        return dict(
             snippet=dict(
             snippet=dict(
-                title=title,
-                description=description,
-                # tags=tags,
-                # categoryId=category,
-                # defaultLanguage
+                title=self.get_title(audiobook),
+                description=self.get_description(audiobook),
+                categoryId=self.category,
+                defaultLanguage='pl',
+                defaultAudioLanguage='pl',
             ),
             status=dict(
             ),
             status=dict(
-                privacyStatus=privacy,
-                # license
-                # selfDeclaredMadeForKids
+                privacyStatus=self.privacy_status,
             ),
             ),
-            # recordingDetails=dict(
-            # recordingDate
-            # ),
         )
         )
+
+    def publish(self, audiobook, path):
+        data = self.get_data(audiobook)
         part = ",".join(data.keys())
 
         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},
-                data=data,
-                media_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'])
         data = response.json()
         audiobook.youtube_id = data['id']
         audiobook.save(update_fields=['youtube_id'])
+
+        self.update_thumbnail(audiobook)
         return response
 
         return response
 
+    def update_data(self, audiobook):
+        data = self.get_data(audiobook)
+        data['id'] = audiobook.youtube_id
+        part = ",".join(data.keys())
+        youtube_call(
+            "PUT",
+            "https://www.googleapis.com/youtube/v3/videos",
+            params={"part": part},
+            json=data
+        )       
+
     def prepare_file(self, input_path, output_path=None):
     def prepare_file(self, input_path, output_path=None):
-        duration = get_duration(input_path)
+        audio = self.prepare_audio(input_path)
+        duration = self.get_duration(input_path)
         video = self.prepare_video(duration)
         video = self.prepare_video(duration)
-        output = mux([video, input_path], output_path=output_path)
+        output = mux([video, audio], output_path=output_path)
+        unlink(audio)
         unlink(video)
         return output
 
         unlink(video)
         return output
 
+    def get_duration(self, input_path):
+        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):
+        files = []
+        if self.intro_flac:
+            files.append(standardize_audio(self.intro_flac.path))
+        files.append(standardize_audio(input_path, cache=False))
+        if self.outro_flac:
+            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 = []
     def prepare_video(self, duration):
         concat = []
+        outro = []
         delete = []
 
         if self.loop_video:
             fps = get_framerate(self.loop_video.path)
         delete = []
 
         if self.loop_video:
             fps = get_framerate(self.loop_video.path)
+            loop_video = standardize_video(self.loop_video.path)
         else:
             fps = 25
 
         loop_duration = duration
         else:
             fps = 25
 
         loop_duration = duration
-        if self.intro_card and self.intro_card_duration:
-            loop_duration -= self.intro_card_duration
-            intro = video_from_image(
-                self.intro_card.path, self.intro_card_duration, fps=fps
-            )
-            concat.append(intro)
-            delete.append(intro)
-
-        if self.outro_card and self.outro_card_duration:
-            loop_duration -= self.outro_card_duration
-            outro = video_from_image(
-                self.outro_card.path, self.outro_card_duration, fps=fps
+        for card in self.card_set.filter(duration__gt=0):
+            loop_duration -= card.duration
+            card_video = video_from_image(
+                card.image.path, card.duration, fps=fps
             )
             )
-            concat.append(outro)
-            delete.append(outro)
+            (concat if card.order < 0 else outro).append(card_video)
+            delete.append(card_video)
 
         if self.loop_video:
 
         if self.loop_video:
-            loop_video_duration = get_duration(self.loop_video.path)
+            loop_video_duration = get_duration(loop_video)
             times_loop = int(loop_duration // loop_video_duration)
 
             leftover_duration = loop_duration % loop_video_duration
             times_loop = int(loop_duration // loop_video_duration)
 
             leftover_duration = loop_duration % loop_video_duration
-            leftover = cut_video(self.loop_video.path, leftover_duration)
-            concat[1:1] = [self.loop_video.path] * times_loop + [leftover]
+            leftover = cut_video(loop_video, leftover_duration)
+            concat.extend([loop_video] * times_loop + [leftover])
             delete.append(leftover)
         else:
             delete.append(leftover)
         else:
-            leftover = video_from_image(self.card.path, loop_duration)
-            concat.insert(1, video_from_image(self.card.path, loop_duration, fps=fps))
+            leftover = video_from_image(self.loop_card.path, loop_duration)
+            concat.append(video_from_image(self.loop_card.path, loop_duration, fps=fps))
             delete.append(leftover)
             delete.append(leftover)
+        concat.extend(outro)
 
         output = concat_videos(concat)
         for p in delete:
             unlink(p)
 
         output = concat_videos(concat)
         for p in delete:
             unlink(p)
+        unlink(loop_video)
         return output
 
     # tags
     # license
     # selfDeclaredMadeForKids
         return output
 
     # tags
     # license
     # selfDeclaredMadeForKids
+
+    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(),
+        )
+
+    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
+        
+
+class Card(models.Model):
+    youtube = models.ForeignKey(YouTube, models.CASCADE)
+    order = models.SmallIntegerField()
+    image = models.FileField(upload_to='youtube/card')
+    duration = models.FloatField()
+
+    class Meta:
+        ordering = ('order', )
+
+
+class Font(models.Model):
+    name = models.CharField(max_length=255, unique=True)
+    truetype = models.FileField(upload_to='youtube/font')
+
+    def __str__(self):
+        return self.name