translator.py

import llfuse
import os
import sqlfuse
import threading

from mbdata.models import Recording, Release, ReleaseGroup, Track, Artist, ArtistCredit, ArtistCreditName, Medium
from sqlalchemy import distinct
from sqlalchemy.sql import select, join
from sqlfuse import QPath, FPath, Where, Functions

class Translator(threading.Thread):
    """
    Manages the mapping between filesystem and database.
    """
    def __init__(self, session_fac, mountpoint):
        super().__init__(target=self)
        self._session = session_fac()
        self._filesystem = sqlfuse.init(self._session, self._create_fs())
        self._mountpoint = mountpoint

    def _create_fs(self):
        fs = [QPath("/Recordings/<recording>",
                    select([Recording.name, Recording.gid, Recording.ftype, Recording.path, ArtistCredit.name]).select_from(join(Recording, ArtistCredit)),
                    Functions(ArtistCredit.name, ' - ', Recording.name, '.', Recording.ftype)),
              #FPath("/Recordings/<and>", Translator._and, is_dir=True),
              #FPath("/Recordings/<or>", Translator._or, is_dir=True),
              QPath("/Artists/<artist>", select([Artist.name, Artist.gid]), Functions(Artist.name)),
              QPath("/Artists/<artist>/Recordings/<recording>",
                    select([Recording.name, Recording.gid, Recording.ftype, Recording.path]).select_from(join(join(join(Recording, ArtistCredit), ArtistCreditName), Artist)),
                    Functions(Recording.name, '.', Recording.ftype),
                    where=[Where(Artist.gid.__eq__, "<artist>", "artist_gid")]),
              #("/Artists/<artist>/Recordings/<and>", _and),
              #("/Artists/<artist>/Recordings/<or>", _or),
              QPath("/Artists/<artist>/<releasegroup>",
                    select([ReleaseGroup.name, ReleaseGroup.id]).select_from(join(join(join(ReleaseGroup, ArtistCredit), ArtistCreditName), Artist)),
                    Functions(ReleaseGroup.name),
                    where=[Where(Artist.gid.__eq__, "<artist>", "artist_gid")]),
              QPath("/Artists/<artist>/<releasegroup>/<release>",
                    select([Release.name, Release.gid, Release.release_group_id]),
                    Functions(Release.name, '.', Release.gid),
                    where=[Where(Release.release_group_id.__eq__, '<releasegroup>', 'release_group_id')]),
              QPath("/Artists/<artist>/<releasegroup>/<release>/<track>",
                    select([Track.name, Track.number, Recording.gid, Recording.path, Recording.ftype]).select_from(join(join(join(Track, Recording), Medium), Release)),
                    Functions(Track.number, ' ', Track.name, '.', Recording.ftype),
                    where=[Where(Release.gid.__eq__, '<release>', 'release_gid')]),
              #("/Artists/<artist>/<releasegroup>/<release>/<and>", _and),
              #("/Artists/<artist>/<releasegroup>/<release>/<or>", _or),
              #QPath("/Artists/<artist>/Works/<work>"
              #("/Artists/<artist>/Works/<work>/<recording>"
              #("/Artists/<artist>/Works/<work>/<and>", _and),
              #("/Artists/<artist>/Works/<work>/<or>", _or),
              QPath("/Releases/<releasegroup>",
                    select([ReleaseGroup.name, ReleaseGroup.id]),
                    Functions(ReleaseGroup.name)),
              QPath("/Releases/<releasegroup>/<release>",
                    select([Release.name, Release.gid, Release.release_group_id]),
                    Functions(Release.name, '.', Release.gid),
                    where=[Where(Release.release_group_id.__eq__, '<releasegroup>', 'release_group_id')]),
              QPath("/Releases/<releasegroup>/<release>/<track>",
                    select([Track.name, Track.number, Recording.gid, Recording.path, Recording.ftype]).select_from(join(join(join(Track, Recording), Medium), Release)),
                    Functions(Track.number, ' ', Track.name, '.', Recording.ftype),
                    where=[Where(Release.gid.__eq__, '<release>', 'release_gid')])]
              #("/Releases/<releasegroup>/<release>/<and>", _and),
              #("/Releases/<releasegroup>/<release>/<or>", _or),
              #("/Works"
              #("/Works/<work>"
              #("/Works/<work>/<recording>"
              #("/Works/<work>/<and>", _and),
              #("/Works/<work>/<or>", _or),
              #("/Year/"
              #("/Year/After/"
              #("/Year/After/<year>"
              #("/Year/After/<year>/<recording>"
              #("/Year/After/<year>/<and>", _and),
              #("/Year/After/<year>/<or>", _or),
              #("/Year/Before/"
              #("/Year/Before/<year>"
              #("/Year/Before/<year>/<recording>"
              #("/Year/Before/<year>/<and>", _and),
              #("/Year/Before/<year>/<or>", _or),
              #("/Year/Between/"
              #("/Year/Between/<year> and"
              #("/Year/Between/<year> and/<year>"
              #("/Year/Between/<year> and/<year>/<recording>"
              #("/Year/Between/<year> and/<year>/<and>", _and),
              #("/Year/Between/<year> and/<year>/<or>", _or),
              #("/Year/<year>"
              #("/Playlists/<name>"
              #("/Playlists/<name>/<recording>"
              #("/Playlists/<name>/<and>", _and),
              #("/Playlists/<name>/<or>", _or),
              #("/RecordingsAsLink/<recording>", _recording_link),
              #("/settings.txt", _settings),
              #FPath("/log.txt", Translator._log, is_dir=False)]
        return fs

    def _result_to_string(result):
        return result.name

    def run(self):
        self.mount(self._mountpoint)

    def mount(self, mountpoint):
        # from utils import debug_breakpoint
        # debug_breakpoint()
        fuse_options = set(llfuse.default_options)
        fuse_options.add('fsname=brainzfs')
        llfuse.init(self._filesystem, self._mountpoint, fuse_options)
        try:
            llfuse.main(workers=1)
        except:
            llfuse.close(unmount=False)
            raise

        llfuse.close()
        # TODO fix
        self._session.commit()
        self._session.close()