symuid/symuid/__init__.py

# -*- coding: utf-8 -*-

import datetime as dt
import dateutil.tz
import mutagen
import os
import re

import symuid.tag_interface


def _timestamp_to_utc_dt(ts):
    return dt.datetime.utcfromtimestamp(ts) \
        .replace(tzinfo=dateutil.tz.tzutc())

assert _timestamp_to_utc_dt(1528795204) \
    == dt.datetime(2018, 6, 12, 9, 20, 4, tzinfo=dateutil.tz.tzutc())


class PlayCount:

    def __init__(self, player, library_id, register_dt, count):
        self.player = player
        self.library_id = library_id
        assert isinstance(register_dt, dt.datetime), register_dt
        assert register_dt.tzinfo is not None, register_dt
        self.register_dt = register_dt
        assert isinstance(count, int) and count >= 0, count
        self.count = count


class Track:

    PATH_DEFAULT_IGNORE_REGEX = r'\.(itdb|itc2|itl|jpg|midi?|plist|xml|zip)$'

    def __init__(self, path):
        mutagen_file = mutagen.File(filename=path)
        if mutagen_file is None:
            raise NotImplementedError(path)
        elif isinstance(mutagen_file.tags, mutagen.id3.ID3):
            self._iface = symuid.tag_interface.ID3(mutagen_file)
        elif isinstance(mutagen_file.tags, mutagen.mp4.MP4Tags):
            self._iface = symuid.tag_interface.MP4(mutagen_file)
        else:
            raise NotImplementedError((path, type(mutagen_file)))

    @property
    def path(self):
        return self._iface.track_path

    def get_uuid(self):
        return self._iface.get_track_uuid()

    def assign_uuid(self, uuid):
        if self.get_uuid():
            raise Exception("{!r} already has an uuid".format(self.path))
        self._iface.set_track_uuid(uuid)
        self._iface.save()

    def _get_play_counts(self, player=None, library_id=None):
        label = 'symuid:pcnt'
        assert library_id is None or player is not None
        if player:
            label += ':' + player
            if library_id:
                label += ':' + library_id
        elif library_id:
            raise Exception((player, library_id))
        for k, c in self._iface.get_free_ints(label):
            player, library_id, register_ts_dec = k.split(':')[2:]
            yield PlayCount(
                player=player,
                library_id=library_id,
                register_dt=_timestamp_to_utc_dt(int(register_ts_dec)),
                count=c,
            )

    def _get_latest_play_counts(self, player=None, library_id=None):
        latest = {}
        for count in self._get_play_counts(player, library_id):
            if not count.player in latest:
                latest[count.player] = {}
            if not count.library_id in latest[count.player] \
                    or latest[count.player][count.library_id].register_dt < count.register_dt:
                latest[count.player][count.library_id] = count
        return [c for p in latest.values() for c in p.values()]

    def get_latest_play_count(self, player, library_id):
        assert player is not None, player
        assert library is not None, library_id
        counts = self._get_latest_play_counts(player, library_id)
        if len(counts) == 0:
            return None
        else:
            assert len(counts) == 1, counts
            return counts[0]

    def get_play_count_sum(self, player=None, library_id=None):
        return sum(c.count for c in self._get_latest_play_counts(player, library_id))

    def register_play_count(self, player, library_id, register_dt, play_count, tag_set_cb=None):
        # TODO accept PlayCount as param
        assert isinstance(register_dt, dt.datetime), register_dt
        assert isinstance(play_count, int), play_count
        tag_label = 'symuid:pcnt:{}:{}:{:.0f}'.format(
            player, library_id, register_dt.timestamp(),
        )
        current_count = self._iface.get_free_int(tag_label)
        if current_count is None:
            new_tag = self._iface.set_free_int(tag_label, play_count)
            self._iface.save()
            if tag_set_cb:
                tag_set_cb(self, new_tag)
        elif current_count != play_count:
            raise Exception((current_count, play_count))

    @classmethod
    def walk(cls, root_path, path_ignore_regex, ignored_cb=None, unsupported_cb=None):
        for dirpath, dirnames, filenames in os.walk(root_path):
            for filename in filenames:
                track_path = os.path.join(dirpath, filename)
                if path_ignore_regex.search(track_path):
                    if ignored_cb is not None:
                        ignored_cb(track_path)
                else:
                    try:
                        yield cls(track_path)
                    except NotImplementedError as e:
                        if unsupported_cb is not None:
                            unsupported_cb(track_path, e)