RadioPlayer/radioPlayer.py

#!/usr/bin/env python3
import os, socket
import random
import subprocess
import time, datetime
import sys
from datetime import datetime
import log95

MORNING_START = 6
MORNING_END = 10
DAY_START = 10
DAY_END = 20
LATE_NIGHT_START = 0
LATE_NIGHT_END = 6

playlist_dir = "/home/user/playlists"
name_table_path = "/home/user/mixes/name_table.txt"

rds_base = "Gramy: radio95 - {}"
rds_default_name = "Program Godzinny"
rds_default_rtp_data = "4,7,7,1,17"

udp_host = ("127.0.0.1", 5000)

logger = log95.log95("radioPlayer")

def get_current_hour():
    return datetime.now().hour

def get_current_day():
    return datetime.now().strftime('%A').lower()

def load_dict_from_custom_format(file_path: str) -> dict:
    try:
        result_dict = {}
        with open(file_path, 'r') as file:
            for line in file:
                if line.strip() == "":
                    continue
                key, value = line.split(':', 1)
                result_dict[key.strip()] = value.strip()
        return result_dict
    except FileNotFoundError:
        logger.error(f"{name_table_path} does not exist, or could not be accesed")
        return {}

def update_rds(track_name):
    try:
        name_table = load_dict_from_custom_format(name_table_path)
        try:
            prt = rds_base.format(name_table[track_name])
        except KeyError as e:
            logger.warning(f"File does not have a alias in the name table ({e})")
            prt = rds_base.format(rds_default_name)

        f = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        f.settimeout(1.0)
        try:
            f.sendto(f"TEXT={prt}\r\n".encode(), udp_host)
        except socket.timeout:
            logger.error("Could not send TEXT to RDS, timeout.")
            return

        try:
            try:
                f.sendto(f"RTP={rds_default_rtp_data},{len(str(name_table[track_name]))-1}\r\n".encode(), udp_host)
            except KeyError:
                f.sendto(f"RTP={rds_default_rtp_data},{len(rds_default_name)-1}\r\n".encode(), udp_host)
        except socket.timeout:
            logger.error("Could not send TEXT to RDS, timeout.")
            return
        f.close()
    except Exception as e:
        logger.error(f"Error updating RDS: {e}")

def get_playlist_modification_time(playlist_path):
    try:
        return os.path.getmtime(playlist_path)
    except OSError:
        return 0

def load_playlist(playlist_path):
    try:
        with open(playlist_path, 'r') as f:
            tracks = [line.strip() for line in f.readlines() if line.strip()]
        return tracks
    except FileNotFoundError:
        logger.error(f"Playlist not found: {playlist_path}")
        return []

def get_newest_track(tracks):
    if not tracks:
        return None
    
    newest_track = None
    newest_time = 0
    
    for track in tracks:
        track_path = os.path.abspath(os.path.expanduser(track))
        try:
            mod_time = os.path.getmtime(track_path)
            if mod_time > newest_time:
                newest_time = mod_time
                newest_track = track
        except OSError:
            continue
    
    return newest_track

def check_control_files():
    """Check for control files and return action to take"""
    if can_delete_file("/tmp/radioPlayer_quit"):
        os.remove("/tmp/radioPlayer_quit")
        return "quit"
    
    if can_delete_file("/tmp/radioPlayer_reload"):
        os.remove("/tmp/radioPlayer_reload")
        return "reload"
    
    return None

def play_playlist(playlist_path, custom_playlist: bool=False, play_newest_first=False, do_shuffle=True):
    last_modified_time = get_playlist_modification_time(playlist_path)
    tracks = load_playlist(playlist_path)
    if not tracks:
        logger.info(f"No tracks found in {playlist_path}, checking again in 15 seconds...")
        time.sleep(15)
        return

    if do_shuffle: random.seed()
    if play_newest_first:
        newest_track = get_newest_track(tracks)
        if newest_track:
            logger.info(f"Playing newest track first: {os.path.basename(newest_track)}")
            tracks.remove(newest_track)
            if do_shuffle: random.shuffle(tracks)
            tracks.insert(0, newest_track)
    else:
        if do_shuffle:
            random.shuffle(tracks)

    for track in tracks:
        current_modified_time = get_playlist_modification_time(playlist_path)
        if current_modified_time > last_modified_time:
            logger.info(f"Playlist {playlist_path} has been modified, reloading...")
            return

        current_hour = get_current_hour()
        current_day = get_current_day()
        morning_playlist_path = os.path.join(playlist_dir, current_day, 'morning')
        day_playlist_path = os.path.join(playlist_dir, current_day, 'day')
        night_playlist_path = os.path.join(playlist_dir, current_day, 'night')
        late_night_playlist_path = os.path.join(playlist_dir, current_day, 'late_night')

        if DAY_START <= current_hour < DAY_END and not custom_playlist:
            if playlist_path != day_playlist_path:
                logger.info("Time changed to day hours, switching playlist...")
                return
        elif MORNING_START <= current_hour < MORNING_END and not custom_playlist:
            if playlist_path != morning_playlist_path:
                logger.info("Time changed to morning hours, switching playlist...")
                return
        elif LATE_NIGHT_START <= current_hour < LATE_NIGHT_END and not custom_playlist:
            if playlist_path != late_night_playlist_path:
                logger.info("Time changed to late night hours, switching playlist...")
                return
        else:
            if playlist_path != night_playlist_path and not custom_playlist:
                logger.info("Time changed to night hours, switching playlist...")
                return

        track_path = os.path.abspath(os.path.expanduser(track))
        track_name = os.path.basename(track_path)
        logger.info(f"Now playing: {track_name}")
        update_rds(track_name)

        subprocess.run(['ffplay', '-nodisp', '-hide_banner', '-autoexit', '-loglevel', 'quiet', track_path], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)

        # Check control files after each song
        action = check_control_files()
        if can_delete_file("/tmp/radioPlayer_onplaylist"): action = None
        if action == "quit":
            exit()
        elif action == "reload":
            logger.info("Reload requested, restarting with new arguments...")
            return "reload"

def can_delete_file(filepath):
    if not os.path.isfile(filepath):
        return False
    directory = os.path.dirname(os.path.abspath(filepath)) or '.'
    return os.access(directory, os.W_OK | os.X_OK)

def parse_arguments():
    """Parse command line arguments and return configuration"""
    arg = sys.argv[1] if len(sys.argv) > 1 else None
    play_newest_first = False
    do_shuffle = True
    pre_track_path = None
    selected_list = None
    
    if arg:
        if arg.lower() == "-h":
            print("Control files:")
            print("    Note: All of these files are one-time only, after they have been acked by the player they will be deleted")
            print("   /tmp/radioPlayer_quit          -   Quit the player")
            print("   /tmp/radioPlayer_reload        -   Reload arguments from /tmp/radioPlayer_arg")
            print("   /tmp/radioPlayer_onplaylist    -   React to quit or reload only when ending a playlist")
            print("   /tmp/radioPlayer_arg           -   Contains arguments to use")
            print()
            print("Arguments:")
            print("    n                        -    Play newest song first")
            print("    list:playlist;options    -    Play custom playlist with options")
            print("    /path/to/file            -    Play specific file first")
            exit(0)
    
    if can_delete_file("/tmp/radioPlayer_arg"):
        with open("/tmp/radioPlayer_arg", "r") as f:
            arg = f.read().strip()
        os.remove("/tmp/radioPlayer_arg")

    if arg:
        if arg.lower() == "n":
            play_newest_first = True
            logger.info("Newest song will be played first")
        elif arg.startswith("list:"):
            selected_list = arg.removeprefix("list:")
            logger.info(f"The list {selected_list.split(';')[0]} will be played instead of the daily section lists.")
            for option in selected_list.split(";"):
                if option == "n":
                    play_newest_first = True
                elif option == "ns":
                    do_shuffle = False
            selected_list = selected_list.split(";")[0]
        elif os.path.isfile(arg):
            pre_track_path = arg
            logger.info(f"Will play requested song first: {arg}")
        else:
            logger.error(f"Invalid argument or file not found: {arg}")

    return arg, play_newest_first, do_shuffle, pre_track_path, selected_list

def main():
    while True:  # Main reload loop
        arg, play_newest_first, do_shuffle, pre_track_path, selected_list = parse_arguments()
        
        if pre_track_path:
            track_name = os.path.basename(pre_track_path)
            logger.info(f"Now playing: {track_name}")
            update_rds(track_name)
            subprocess.run(['ffplay', '-nodisp', '-hide_banner', '-autoexit', '-loglevel', 'quiet', pre_track_path], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
            
            action = check_control_files()
            if can_delete_file("/tmp/radioPlayer_onplaylist"): action = None
            if action == "quit":
                exit()
            elif action == "reload":
                logger.info("Reload requested, restarting with new arguments...")
                continue  # Restart the main loop

        playlist_loop_active = True
        while playlist_loop_active:
            if selected_list:
                logger.info("Playing custom list")
                result = play_playlist(selected_list, True, play_newest_first, do_shuffle)
                if result == "reload":
                    playlist_loop_active = False  # Break out to reload
                continue
            
            current_hour = get_current_hour()
            current_day = get_current_day()

            morning_playlist = os.path.join(playlist_dir, current_day, 'morning')
            day_playlist = os.path.join(playlist_dir, current_day, 'day')
            night_playlist = os.path.join(playlist_dir, current_day, 'night')
            late_night_playlist = os.path.join(playlist_dir, current_day, 'late_night')

            morning_dir = os.path.dirname(morning_playlist)
            day_dir = os.path.dirname(day_playlist)
            night_dir = os.path.dirname(night_playlist)
            late_night_dir = os.path.dirname(late_night_playlist)
            
            for dir_path in [morning_dir, day_dir, night_dir, late_night_dir]:
                if not os.path.exists(dir_path):
                    logger.info(f"Creating directory: {dir_path}")
                    os.makedirs(dir_path, exist_ok=True)

            for playlist_path in [morning_playlist, day_playlist, night_playlist, late_night_playlist]:
                if not os.path.exists(playlist_path):
                    logger.info(f"Creating empty playlist: {playlist_path}")
                    with open(playlist_path, 'w') as f:
                        pass

            if DAY_START <= current_hour < DAY_END:
                logger.info(f"Playing {current_day} day playlist...")
                result = play_playlist(day_playlist, False, play_newest_first, do_shuffle)
            elif MORNING_START <= current_hour < MORNING_END:
                logger.info(f"Playing {current_day} morning playlist...")
                result = play_playlist(morning_playlist, False, play_newest_first, do_shuffle)
            elif LATE_NIGHT_START <= current_hour < LATE_NIGHT_END:
                logger.info(f"Playing {current_day} late_night playlist...")
                result = play_playlist(late_night_playlist, False, play_newest_first, do_shuffle)
            else:
                logger.info(f"Playing {current_day} night playlist...")
                result = play_playlist(night_playlist, False, play_newest_first, do_shuffle)
                
            action = check_control_files()
            if not can_delete_file("/tmp/radioPlayer_onplaylist"): action = None
            if action == "quit":
                os.remove("/tmp/radioPlayer_onplaylist")
                exit()
            elif action == "reload":
                os.remove("/tmp/radioPlayer_onplaylist")
                logger.info("Reload requested, restarting with new arguments...")
                result = "reload"
            
            if result == "reload":
                playlist_loop_active = False  # Break out to reload
                

if __name__ == '__main__':
    main()