uho/mk_show.py

#!/usr/bin/python3

import sys, os, datetime, fnmatch, glob, random, time, pathlib, re
from datetime import timedelta
from os.path import join
from tinytag import TinyTag 
from random import shuffle
import sqlite3, json

from mk_web import *

conn = sqlite3.connect("database/music.db")

#cursor = conn.cursor()
#cursor.execute("DROP TABLE SHOW")
#conn.commit()

conn.execute('''CREATE TABLE IF NOT EXISTS SHOW(
ID INTEGER PRIMARY KEY     AUTOINCREMENT,
EPISODE        INT    NOT NULL,
DATE           TEXT     NOT NULL,
DURATION      INT     NOT NULL,
ALBUM        TEXT     NOT NULL,
TRACK        TEXT     NOT NULL,
ARTIST        TEXT     NOT NULL,
TRACKDUR       INT     NOT NULL,
YEAR        TEXT     NOT NULL
);''')

print("Table created successfully");

#conn.execute("INSERT INTO SHOW (ID, EPISODE,DATE,TRACK,ARTIST) \
#VALUES (1, 1, 'wednesday', 'Some song', 'Some Artist' )");
#conn.commit()
#print("DB Record created successfully");
#conn.close()



episode_date = datetime.datetime.now().strftime("%Y-%m-%d")
episode_duration = 0
complete_playlist = []
show_array = []
show_cover = ""
archive = []
artists_played = []
artist_abreviated = []
episode_number = sys.argv[1]
show_name = "SHOWNAME" # OBED
path = "/home/rob/antena/"
web_path = "/home/rob/antena/html/episode/{0}/img".format(episode_number)

if os.path.exists(web_path):
    print("path_exists_doing_nothing")
else: os.makedirs(web_path)

# /////////////////////////////////////////////////

def create_intro(show_array):
    intropath = path + "texts/clips/this_is"
    intro = random.choice(os.listdir(intropath))
    show_array.insert(0, str(os.path.abspath(intropath)) + "/"  + str(intro))

def add_to_tracks_played(add_to_played: str):
    with open('playlists/track_playout_history.txt', "a") as tracks_played_file:
        tracks_played_file.write(str(add_to_played) + "\n") # newline \n needed here?

def check_archive(track):
    global archive
    with open('playlists/track_playout_history.txt') as archive_file:
        for line in archive_file:
            archive.append(line)
    if track not in archive:
        print("____ TRACK NOT YET PLAYED ... ADDING _____")
        return True
    else:
        print("____ TRACK ALREADY PLAYED _____")
        return False

def load_all_music():
    with open('playlists/complete_music_archive.pls') as playlist_file:
        for line in playlist_file:
            complete_playlist.append(line)
        print('''
        -------------------------------
        loaded {0} tracks from playlist
        -------------------------------
        '''.format(str(len(complete_playlist))))
    return complete_playlist

def create_show_playlist(show_array: list, complete_playlist:list):
    load_all_music()

    global episode_duration
    global archive

    track_count = 0
    global artists_played 
    max_track_dur = 10
    min_track_dur = 1.8
    
    while episode_duration  < 60 * 60 and track_count < 12 :
        song = random.choice(random.sample(\
               complete_playlist, len(complete_playlist) )).rstrip() #  pick a song
        track = TinyTag.get(song) # get its metadata
        # check if the artist not in the played list and the song is less than 8mins
        if track.artist not in artists_played:
           if  check_archive(track.title) is True:
               if  int(track.duration) > min_track_dur * 60:  
                   if  int(track.duration) < max_track_dur * 60:  
                       show_array.append(song.rstrip()) # if 'not in' is true then add the song
                       art =  string=re.sub("\(.*?\)","",track.artist)
                       # shorten verbose artist names such as trojnik Trojnik (Cene Resnik, Tomaž Grom, Vid Drašler) 
                       art =  string=re.sub("and","&",art)
                       artist_abreviated.append(art)
                       artists_played.append(track.artist) # and add the artist to the played list
                       add_to_tracks_played(track.title) # and write entry to archive file 

                       if not track.year: # where missing metadata give a dummy value
                           track.year = 0000
                       
                       cursor = conn.cursor()
                       #long_string = json.dumps(["' SomeWord"])
                       cursor.execute("INSERT INTO SHOW (\
                       ID, EPISODE, DATE, DURATION, ALBUM, TRACK, ARTIST, TRACKDUR, YEAR) \
                       VALUES (NULL, ?, ?, ?, ?, ?, ?,?,?)", [episode_number, episode_date, episode_duration, \
                                                              track.album, track.title, track.artist, track.duration, track.year]);
                       conn.commit()                      
                       print("DB Record created successfully");



                       

                       track_count += 1; print(track_count)
                       episode_duration = episode_duration + track.duration 
                   else: print("TRACK TOO SHORT..........." )
               else: print("TRACK TOO LONG..........." )
           else: print("SONG PLAYED IN PREVIOUS EPISODE" )
        else: print("ARTIST ALREADY IN PODCAST")

    conn.close() 
        
    episode_duration = timedelta(seconds=round(episode_duration))

    print("total tracks = {0} \n total duration = {1} ".format(track_count, episode_duration))

    return show_array, episode_duration

def combine_images(columns, space, images, variants:int):
    global show_cover
    
    from PIL import Image
    from PIL import ImageDraw
    from PIL import ImageFont

    rows = len(images) // columns

    if len(images) % columns:
        rows += 1

    width_max = 500 #max([Image.open(image).width for image in images])
    height_max = 500# max([Image.open(image).height for image in images])
    background_width = width_max*columns + (space*columns)-space
    background_height = height_max*rows + (space*rows)-space
    #background = Image.new('RGBA', (background_width, background_height), (0, 0, 0, 255))
    background = Image.new('RGBA', (width_max*columns , height_max*columns), (0, 0, 0, 255))
    
    x = 0
    y = 0

    for i, image in enumerate(images):
        imga = Image.open(image)
        size = (500,500)
        img = imga.resize(size)
        x_offset = int((width_max-img.width)/2)
        y_offset = int((height_max-img.height)/2)
        background.paste(img, (x+x_offset, y+y_offset+100))
        x += width_max + space
        if (i+1) % columns == 0:
            y += height_max + space
            x = 0

        im = ImageDraw.Draw(background)
        mf_h1 = ImageFont.truetype('fonts/Antonio-Light.ttf', 280)
        mf_h2 = ImageFont.truetype('fonts/Antonio-Light.ttf', 65)
        mf_h3 = ImageFont.truetype('fonts/Antonio-Regular.ttf', 50)
        mf_h4 = ImageFont.truetype('fonts/Antonio-Light.ttf', 50)
           
        h2_spc = 85
        h2_baseline = 1530
      
    # Add Text to the image ----------------------------------------
    # -------------------------------------------------------------------
    # some logic to shuffle the list if sub sections of list are too long for layout
    str_length_thresh = 50
    while \
       [len(s) for s in [''.join(artist_abreviated[0:3])]][0] > str_length_thresh   or\
       [len(s) for s in [''.join(artist_abreviated[3:6])]][0] > str_length_thresh  or\
       [len(s) for s in [''.join(artist_abreviated[6:9])]][0] > str_length_thresh  or \
       [len(s) for s in [''.join(artist_abreviated[9:12])]][0] > str_length_thresh:
        print("on of the lines is longer than fits the page... shuffling the list for a better look")
        random.shuffle(artist_abreviated)
      
    im.text((30,10), '''an eclectic selection of contemporary independent music from slovenia: {0} - E P I S O D E  #{1}
    '''\
            .format(episode_date,episode_number), fill="white", font=mf_h3)
    im.text((30,280), ''' THIS WEEK ON \n EPISODE #{0} of \n {1}!'''.upper()\
            .format(episode_number, show_name), fill="white", font=mf_h1, stroke_width=2, stroke_fill='black')
    im.text((30, h2_baseline + (h2_spc*1) ),  '''m u s i c _ f r o m _ :  {0}'''\
            .format(' | '.join(artist_abreviated[0:3])), (255,255,255), font=mf_h2)
    im.text((30, h2_baseline + (h2_spc*2) ), "{0}"\
            .format(' | '.join(artist_abreviated[3:6])), (255,255,255), font=mf_h2)
    im.text((30, h2_baseline + (h2_spc*3)), "{0}"\
            .format(' | '.join(artist_abreviated[6:9])), (255,255,255), font=mf_h2)
    im.text((30, h2_baseline + (h2_spc*4)), "{0}"\
            .format(' | '.join(artist_abreviated[9:12])), (255,255,255), font=mf_h2)

    im.text((1540,1888), ''' http://{0}.rizom.si '''\
            .format(show_name, episode_date,episode_number), fill="white", font=mf_h4)
  
    show_cover = 'img/cover.png'.format(episode_number,episode_date, variants)
    background.save("html/" + "episode/{0}/{1}".format(episode_number, show_cover))
    return show_cover
        
def create_show_coverart(show_array, variants):

    show_cover_jpgs = []

    for dir in show_array:
        path = pathlib.Path(dir).parent
        for file in os.listdir(path):
            for i in ["cover", "COVER"]:
                if i in file:
                    show_cover_jpgs.append(str(path) + "/" + file)

    print('''
    ------------------------
    creating show cover art
    ------------------------
    ''')
  
    #   if len(show_cover_jpgs) > 0: # duplicate this for variations of geometry 
    for i in range(variants):
        x = show_cover_jpgs[:12]
        combine_images(columns=4, space=3, images=random.sample(x,len(x)),variants=i)
        
    return show_cover


def create_animated_gif():
    import contextlib
    from PIL import Image

    # filepaths
    fp_in = "/home/rob/antena/html/episode/2/img/*.png".format(episode_number)
    fp_out = "/home/rob/antena/html/episode/2/img/show_cover.gif"

    # use exit stack to automatically close opened images
    with contextlib.ExitStack() as stack:

        # lazily load images
        imgs = (stack.enter_context(Image.open(f))
                for f in sorted(glob.glob(fp_in)))

        # extract  first image from iterator
        img = next(imgs)

        # https://pillow.readthedocs.io/en/stable/handbook/image-file-formats.html#gif
        img.save(fp=fp_out, format='GIF', append_images=imgs,
                 save_all=True, duration=200, loop=0)

def create_pls_file():
    # write the selection as a playlist file
    with open("shows/antena_playlist_" + episode_date + ".pls","w") as file:                             
        file.writelines("\n".join(show_array))
        
def create_podcast(show_array: list):

    print('''
    ------------------------
    creating show audio
    ------------------------
    ''')

    from glob import glob
    from pydub import AudioSegment

    playlist_songs = [AudioSegment.from_file(flac_file) for flac_file in show_array]

    show_intro = playlist_songs[0]
#    first_song = playlist_songs[0].fade_in(0) # only fadein if used over show intro - currently not used
 #   intro_and_first = first_song.overlay(show_intro)
    first_three_blurb = playlist_songs[0]
    second_three_blurb = playlist_songs[0]
    final_songs_blurb = playlist_songs[0]
    final_show_outro = playlist_songs[0]

    # next two commented lines are for if intro goes over first track or not
    #playlist = intro_and_first

    
    
    playlist = show_intro

    
    #for song in playlist_songs[2:3]:
    for song in playlist_songs[1:4]: # first three songs (first added with intro)
        # We don't want an abrupt stop at the end, so let's do a 1 second crossfades
        playlist = playlist.append(song, crossfade=(1 * 1000))
    print("first songs added")
        
    # blurb about first three tracks
    playlist = playlist.append(first_three_blurb) # <--------------BLURB INSERT

    for song in playlist_songs[4:7]: # second three songs
        playlist = playlist.append(song, crossfade=(1 * 1000))
    print("second songs added")
        
    playlist = playlist.append(second_three_blurb) # <--------------BLURB INSERT

    for song in playlist_songs[7:10]: # second three song
        playlist = playlist.append(song, crossfade=(1 * 1000))
    print("third songs added")

    playlist = playlist.append(final_songs_blurb) # <--------------BLURB INSERT

    for song in playlist_songs[10:13]: # second three song
        playlist = playlist.append(song, crossfade=(1 * 1000))
    print("final songs added")
    
    playlist = playlist.append(final_show_outro) # <-------------- OUTRO SEQUENCE
    
    # get length of final show / podcast
    playlist_length = len(playlist) / (1000*60)
    # save the entire poidcast

    with open("html/episode/{0}/show.flac".format(episode_number), 'wb') as out_f:
        print("FLAC output file opened...writing to file...")
        playlist.export(out_f, format='flac')
        print("FLAC audio file exported...")
        
    with open("html/episode/{0}/show.mp3".format(episode_number), 'wb') as out_f:
        print("MP3 output file opened...writing to file...")
        playlist.export(out_f, format='mp3')
        print("MP3 audio file exported...")

### ------------------------------------------------------------        

def create_html_episode_from_template():

    from jinja2 import Template, Environment, FileSystemLoader

    env = Environment(loader=FileSystemLoader('html/templates'))
    episode_template = env.get_template('episode.jinja')

    show_info = []

    # maybe a jinja2 template loop here instead 
    for i in show_array:
        track = TinyTag.get(i)
        detail = str(track.artist) + " | " + str(track.album)  + \
            " | " + str(track.title) + " | " + str(track.year) + \
            " | " + str(timedelta(seconds=round(track.duration)))
        show_info.append("" + detail)

    output_from_parsed_template = episode_template.render(episode_author="rrrrrrrr",\
        episode_duration=episode_duration, episode_date=episode_date, about_show="bla bla", episode_playlist=show_info, \
        episode_image="img/cover.png".format(episode_number))

    with open("html/episode/{0}/index.html".format(episode_number), "w") as episode_page:
        episode_page.write(output_from_parsed_template)

def create_html_episode_from_template():

    from jinja2 import Template, Environment, FileSystemLoader

    env = Environment(loader=FileSystemLoader('html/templates'))
    episode_template = env.get_template('episode.jinja')

    show_info = []

    # maybe a jinja2 template loop here instead 
    for i in show_array:
        track = TinyTag.get(i)
        detail = str(track.artist) + " | " + str(track.album)  + \
            " | " + str(track.title) + " | " + str(track.year) + \
            " | " + str(timedelta(seconds=round(track.duration)))
        show_info.append("" + detail)

    output_from_parsed_template = episode_template.render(episode_author="rrrrrrrr",\
        episode_duration="123", about_show="bla bla", episode_playlist=show_info, \
        episode_image="img/cover.png".format(episode_number))

    with open("html/episode/{0}/index.html".format(episode_number), "w") as episode_page:
        episode_page.write(output_from_parsed_template)


def create_html_homepage_from_template():

    from jinja2 import Template, Environment, FileSystemLoader

    env = Environment(loader=FileSystemLoader('html/templates'))
    homepage_template = env.get_template('homepage.jinja')

    show_info = []

    episode_artists = []
    for i in range(10):
        artists = []
        conn = sqlite3.connect("database/music.db")
        cur = conn.cursor()
        cur.execute("SELECT ARTIST FROM SHOW WHERE EPISODE=?", [i])
        rows = cur.fetchall()

        for artist in rows:
            art =  string=re.sub("\(.*?\)","", artist[0])
            # shorten verbose artist names such as trojnik Trojnik (Cene Resnik, Tomaž Grom, Vid Drašler) 
            artist =  string=re.sub("and","&",art)
            artists.append(artist)
        episode_artists.append(artists)


    episodes = []
    for i in range(10):
       
        print(episode_artists)
        an_episode = dict(date="2012-02-", episode_artists=episode_artists[i], episode_number=i, episode_date=episode_date, episode_duration=episode_duration)
        episodes.append(an_episode)
    episodes = reversed(episodes) # reversed order to most recent episode appears first in list

        
    # maybe a jinja2 template loop here instead 
    for i in show_array:
        track = TinyTag.get(i)
        detail = str(track.artist) + " | " + str(track.album)  + \
            " | " + str(track.title) + " | " + str(track.year) + \
            " | " + str(timedelta(seconds=round(track.duration)))
        show_info.append("" + detail)

    output_from_parsed_template = homepage_template.render(episodes=episodes, episode_author="Rob Canning",\
                                                           episode_duration="123", episode_number=episode_number, episode_artists=episode_artists, \
                                                           about_show="bla bla", episode_playlist=show_info, \
        episode_image="episode/{0}/img/cover.png".format(episode_number))

    with open("html/index.html".format(episode_number), "w") as episode_page:
        episode_page.write(output_from_parsed_template)


create_show_playlist(show_array, complete_playlist)
create_show_coverart(show_array, 1)         #episode_duration = 100
#create_animated_gif()


create_intro(show_array)
create_pls_file()

create_html_episode_from_template()
create_html_homepage_from_template()
create_podcast(show_array)


#convert -delay 100 -loop 0 html/episode/2/img/show_cover_2024-01-12* animatedGIF.gif