__init__.py

import re
import time
from fuzzywuzzy.process import extractOne as extract_one

from mycroft.skills.common_play_skill import CommonPlaySkill, CPSMatchLevel

from .mopidypost import Mopidy


NOTHING_FOUND = (None, 0.0)


class MopidySkill(CommonPlaySkill):
    def __init__(self):
        super(MopidySkill, self).__init__('Mopidy Skill')
        self.mopidy = None
        self.volume_is_low = False
        self.regexes = {}

    def _connect(self):
        url = 'http://localhost:6680'
        if self.settings:
            url = self.settings.get('mopidy_url', url)

        try:
            mopidy = Mopidy(url)
        except Exception:
            self.log.warning('Could not connect to Mopidy server')
            return None

        self.log.info('Connected to mopidy server')
        self.cancel_scheduled_event('MopidyConnect')
        self.albums = {}
        self.artists = {}
        self.genres = {}
        self.playlists = {}
        self.radios = {}
        self.track_names = {}

        self.log.info('Loading content')
        self.albums['gmusic'] = mopidy.get_gmusic_albums()
        self.artists['gmusic'] = mopidy.get_gmusic_artists()
        self.genres['gmusic'] = mopidy.get_gmusic_radio()
        self.playlists['gmusic'] = {}
        self.track_names['gmusic'] = {}

        self.albums['local'] = mopidy.get_local_albums()
        self.artists['local'] = mopidy.get_local_artists()
        self.genres['local'] = mopidy.get_local_genres()
        self.playlists['local'] = mopidy.get_local_playlists()
        self.track_names['local'] = mopidy.get_local_track_names()

        self.albums['spotify'] = {}
        self.artists['spotify'] = {}
        self.genres['spotify'] = {}
        self.playlists['spotify'] = mopidy.get_spotify_playlists()
        self.track_names['spotify'] = {}

        self.playlist = {}
        for loc in ['local', 'gmusic', 'spotify']:
            self.log.info(loc)
            self.playlist.update(self.playlists[loc])
            self.log.info(loc)
            self.playlist.update(self.genres[loc])
            self.log.info(loc)
            self.playlist.update(self.artists[loc])
            self.log.info(loc)
            self.playlist.update(self.albums[loc])
            self.log.info(loc)
            self.playlist.update(self.track_names[loc])

        return mopidy

    def initialize(self):
        self.log.info('initializing Mopidy skill')
        super(MopidySkill, self).initialize()

        # Setup handlers for playback control messages
        self.add_event('mycroft.audio.service.next', self.handle_next)
        self.add_event('mycroft.audio.service.prev', self.handle_prev)
        self.add_event('mycroft.audio.service.pause', self.handle_pause)
        self.add_event('mycroft.audio.service.resume', self.handle_resume)

        self.mopidy = self._connect()

    def play(self, tracks):
        self.mopidy.clear_list()
        self.mopidy.add_list(tracks)
        self.mopidy.play()

    def translate_regex(self, regex):
        if regex not in self.regexes:
            path = self.find_resource(regex + '.regex', 'dialog')
            if path:
                with open(path) as f:
                    string = f.read().strip()
                self.regexes[regex] = string
        return self.regexes[regex]

    def CPS_match_query_phrase(self, phrase):
        # If no mopidy connection can be detected return None
        if self.mopidy is None:
            self.mopidy = self._connect()
            if not self.mopidy:
                return None

        self.log.info('Checking Mopidy for {}'.format(phrase))

        mopidy_specified = 'mopidy' in phrase
        phrase = re.sub(self.translate_regex('on_mopidy'), '', phrase)

        match_level = CPSMatchLevel.MULTI_KEY
        match = self.specific_query(phrase)
        # If nothing was found check for a generic match
        if match == NOTHING_FOUND:
            match = self.generic_query(phrase)
            match_level = CPSMatchLevel.GENERIC

        self.log.info('Mopidy match: {}'.format(match))
        if match == NOTHING_FOUND:
            self.log.debug('Nothing found on mopidy')
            return None
        else:
            return (phrase,
                    (CPSMatchLevel.EXACT if mopidy_specified else match_level),
                    {'playlist': match[0],
                     'playlist_type': match[2],
                     'library_type': match[3]
                     })


    def query_song(self, song):
        best_found = None
        best_conf = 0
        library_type = None
        for t in self.track_names:
            found, conf = (extract_one(song, self.track_names[t].keys()) or
                           (None, 0))
            if conf > best_conf and conf > 50:
                best_conf = conf
                best_found = found
                library_type = t
        return best_found, best_conf, 'song', library_type


    def query_artist(self, artist):
        best_found = None
        best_conf = 0.0
        library_type = None
        for t in self.artists:
            found, conf = (extract_one(artist, self.artists[t].keys()) or
                           (None, 0))
            if conf > best_conf and conf > 50:
                best_conf = conf
                best_found = found
                library_type = t
        return best_found, best_conf, 'artist', library_type

    def query_album(self, album):
        best_found = None
        best_conf = 0
        library_type = None
        for t in self.albums:
            self.log.info(self.albums[t].keys())
            found, conf = (extract_one(album, self.albums[t].keys()) or
                           (None, 0))
            if conf > best_conf and conf > 50:
                best_conf = conf
                best_found = found
                library_type = t
        self.log.info('ALBUMS')
        self.log.info((best_found, best_conf))
        return best_found, best_conf, 'album', library_type

    def specific_query(self, phrase):
        """Check if the request is for a specific type.

        This checks, albums, artists, genres and tracks.
        """
        # Check if playlist
        #match = re.match(self.translate_regex('playlist'), phrase)
        #if match:
        #    return self.query_playlist(match.groupdict()['playlist'])

        # Check album
        match = re.match(self.translate_regex('album'), phrase)
        if match:
            album = match.groupdict()['album']
            return self.query_album(album)

        # Check artist
        match = re.match(self.translate_regex('artist'), phrase)
        if match:
            artist = match.groupdict()['artist']
            return self.query_artist(artist)
        match = re.match(self.translate_regex('song'), phrase)
        if match:
            song = match.groupdict()['track']
            return self.query_song(song)
        return NOTHING_FOUND

    def generic_query(self, phrase):
        found, conf = extract_one(phrase, self.playlist.keys())
        if conf > 50:
            return found, conf, 'generic', ''
        else:
            return NOTHING_FOUND

    def CPS_start(self, phrase, data):
        p = data.get('playlist')
        list_type = data.get('playlist_type', 'generic')
        library_type = data.get('library_type', 'generic')

        lists = {'generic': self.playlist,
                 'artist': self.artists,
                 'album': self.albums,
                 'song': self.track_names
                 }
        if list_type == 'generic':
            playlists = lists[list_type]
        else:
            playlists = lists[list_type][library_type]
        self.stop()
        self.speak('Playing {}'.format(p))
        time.sleep(3)
        if playlists[p]['type'] == 'playlist':
            tracks = self.mopidy.get_items(playlists[p]['uri'])
        if playlists[p]['type'] == 'track':
            tracks = playlists[p]['uri']
        else:
            tracks = self.mopidy.get_tracks(playlists[p]['uri'])
        self.play(tracks)

    def stop(self, message=None):
        self.log.info('Handling stop request')
        if self.mopidy:
            self.mopidy.clear_list()
            self.mopidy.stop()

    def handle_next(self, message):
        self.mopidy.next()

    def handle_prev(self, message):
        self.mopidy.previous()

    def handle_pause(self, message):
        self.mopidy.pause()

    def handle_resume(self, message):
        """Resume playback if paused"""
        self.mopidy.resume()

    def lower_volume(self, message):
        self.log.info('lowering volume')
        self.mopidy.lower_volume()
        self.volume_is_low = True

    def restore_volume(self, message):
        self.log.info('maybe restoring volume')
        self.volume_is_low = False
        time.sleep(2)
        if not self.volume_is_low:
            self.log.info('restoring volume')
            self.mopidy.restore_volume()

    def handle_currently_playing(self, message):
        current_track = self.mopidy.currently_playing()
        if current_track is not None:
            self.mopidy.lower_volume()
            time.sleep(1)
            if 'album' in current_track:
                data = {'current_track': current_track['name'],
                        'artist': current_track['album']['artists'][0]['name']}
                self.speak_dialog('currently_playing', data)
            time.sleep(6)
            self.mopidy.restore_volume()


def create_skill():
    return MopidySkill()