musicmuster/app/helpers.py

import os
import psutil

from app.config import Config
from datetime import datetime
from pydub import AudioSegment
from mutagen.flac import FLAC
from mutagen.mp3 import MP3
from PyQt5.QtWidgets import QMessageBox
from tinytag import TinyTag


def fade_point(audio_segment, fade_threshold=0,
               chunk_size=Config.AUDIO_SEGMENT_CHUNK_SIZE):
    """
    Returns the millisecond/index of the point where the volume drops below
    the maximum and doesn't get louder again.
    audio_segment - the sdlg_search_database_uiegment to find silence in
    fade_threshold - the upper bound for how quiet is silent in dFBS
    chunk_size - chunk size for interating over the segment in ms
    """

    assert chunk_size > 0  # to avoid infinite loop

    segment_length = audio_segment.duration_seconds * 1000  # ms
    trim_ms = segment_length - chunk_size
    max_vol = audio_segment.dBFS
    if fade_threshold == 0:
        fade_threshold = max_vol

    while (
        audio_segment[trim_ms:trim_ms + chunk_size].dBFS < fade_threshold
            and trim_ms > 0):       # noqa W503
        trim_ms -= chunk_size

    # if there is no trailing silence, return lenght of track (it's less
    # the chunk_size, but for chunk_size = 10ms, this may be ignored)
    return int(trim_ms)


def get_audio_segment(path):
    try:
        if path.endswith('.mp3'):
            return AudioSegment.from_mp3(path)
        elif path.endswith('.flac'):
            return AudioSegment.from_file(path, "flac")
    except AttributeError:
        return None


def get_tags(path):
    """
    Return a dictionary of title, artist, duration-in-milliseconds and path.
    """

    tag = TinyTag.get(path)

    return dict(
        title=tag.title,
        artist=tag.artist,
        duration=int(round(tag.duration, Config.MILLISECOND_SIGFIGS) * 1000),
        path=path
    )


def get_relative_date(past_date, reference_date=None):
    """
    Return how long before reference_date past_date is as string.

    Params:
        @past_date: datetime
        @reference_date: datetime, defaults to current date and time

        @return: string
    """

    if not past_date:
        return "Never"
    if not reference_date:
        reference_date = datetime.now()

    # Check parameters
    if past_date > reference_date:
        return "get_relative_date() past_date is after relative_date"

    weeks, days = divmod((reference_date.date() - past_date.date()).days, 7)
    if weeks == days == 0:
        # Played today, so return time instead
        return past_date.strftime("%H:%M")
    if weeks == 1:
        weeks_str = "week"
    else:
        weeks_str = "weeks"
    if days == 1:
        days_str = "day"
    else:
        days_str = "days"
    return f"{weeks} {weeks_str}, {days} {days_str} ago"


def leading_silence(audio_segment, silence_threshold=Config.DBFS_SILENCE,
                    chunk_size=Config.AUDIO_SEGMENT_CHUNK_SIZE):
    """
    Returns the millisecond/index that the leading silence ends.
    audio_segment - the segment to find silence in
    silence_threshold - the upper bound for how quiet is silent in dFBS
    chunk_size - chunk size for interating over the segment in ms

    https://github.com/jiaaro/pydub/blob/master/pydub/silence.py
    """

    trim_ms = 0  # ms
    assert chunk_size > 0  # to avoid infinite loop
    while (
        audio_segment[trim_ms:trim_ms + chunk_size].dBFS <      # noqa W504
            silence_threshold and trim_ms < len(audio_segment)):
        trim_ms += chunk_size

    # if there is no end it should return the length of the segment
    return min(trim_ms, len(audio_segment))


def ms_to_mmss(ms, decimals=0, negative=False):
    if not ms:
        return "-"
    sign = ""
    if ms < 0:
        if negative:
            sign = "-"
        else:
            ms = 0

    minutes, remainder = divmod(ms, 60 * 1000)
    seconds = remainder / 1000

    # if seconds >= 59.5, it will be represented as 60, which looks odd.
    # So, fake it under those circumstances
    if seconds >= 59.5:
        seconds = 59.0

    return f"{sign}{minutes:.0f}:{seconds:02.{decimals}f}"


def open_in_audacity(path):
    """
    Open passed file in Audacity

    Return True if apparently opened successfully, else False
    """

    # Return if audacity not running
    if "audacity" not in [i.name() for i in psutil.process_iter()]:
        return False

    to_pipe = '/tmp/audacity_script_pipe.to.' + str(os.getuid())
    from_pipe = '/tmp/audacity_script_pipe.from.' + str(os.getuid())
    EOL = '\n'

    def send_command(command):
        """Send a single command."""
        to_audacity.write(command + EOL)
        to_audacity.flush()

    def get_response():
        """Return the command response."""
        result = ''
        line = ''
        while True:
            result += line
            line = from_audacity.readline()
            if line == '\n' and len(result) > 0:
                break
        return result

    def do_command(command):
        """Send one command, and return the response."""
        send_command(command)
        response = get_response()
        return response

    with open(to_pipe, 'w') as to_audacity, open(
            from_pipe, 'rt') as from_audacity:
        do_command(f'Import2: Filename="{path}"')


def show_warning(title, msg):
    "Display a warning to user"

    QMessageBox.warning(None, title, msg, buttons=QMessageBox.Cancel)


def trailing_silence(audio_segment, silence_threshold=-50.0,
                     chunk_size=Config.AUDIO_SEGMENT_CHUNK_SIZE):
    return fade_point(audio_segment, silence_threshold, chunk_size)