Move common libs to libs/common

libs/common/beetsplug/metasync/__init__.py

@@ -0,0 +1,141 @@
+# -*- coding: utf-8 -*-
+# This file is part of beets.
+# Copyright 2016, Heinz Wiesinger.
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+
+"""Synchronize information from music player libraries
+"""
+
+from __future__ import division, absolute_import, print_function
+
+from abc import abstractmethod, ABCMeta
+from importlib import import_module
+
+from beets.util.confit import ConfigValueError
+from beets import ui
+from beets.plugins import BeetsPlugin
+import six
+
+
+METASYNC_MODULE = 'beetsplug.metasync'
+
+# Dictionary to map the MODULE and the CLASS NAME of meta sources
+SOURCES = {
+    'amarok': 'Amarok',
+    'itunes': 'Itunes',
+}
+
+
+class MetaSource(six.with_metaclass(ABCMeta, object)):
+    def __init__(self, config, log):
+        self.item_types = {}
+        self.config = config
+        self._log = log
+
+    @abstractmethod
+    def sync_from_source(self, item):
+        pass
+
+
+def load_meta_sources():
+    """ Returns a dictionary of all the MetaSources
+    E.g., {'itunes': Itunes} with isinstance(Itunes, MetaSource) true
+    """
+    meta_sources = {}
+
+    for module_path, class_name in SOURCES.items():
+        module = import_module(METASYNC_MODULE + '.' + module_path)
+        meta_sources[class_name.lower()] = getattr(module, class_name)
+
+    return meta_sources
+
+
+META_SOURCES = load_meta_sources()
+
+
+def load_item_types():
+    """ Returns a dictionary containing the item_types of all the MetaSources
+    """
+    item_types = {}
+    for meta_source in META_SOURCES.values():
+        item_types.update(meta_source.item_types)
+    return item_types
+
+
+class MetaSyncPlugin(BeetsPlugin):
+
+    item_types = load_item_types()
+
+    def __init__(self):
+        super(MetaSyncPlugin, self).__init__()
+
+    def commands(self):
+        cmd = ui.Subcommand('metasync',
+                            help='update metadata from music player libraries')
+        cmd.parser.add_option('-p', '--pretend', action='store_true',
+                              help='show all changes but do nothing')
+        cmd.parser.add_option('-s', '--source', default=[],
+                              action='append', dest='sources',
+                              help='comma-separated list of sources to sync')
+        cmd.parser.add_format_option()
+        cmd.func = self.func
+        return [cmd]
+
+    def func(self, lib, opts, args):
+        """Command handler for the metasync function.
+        """
+        pretend = opts.pretend
+        query = ui.decargs(args)
+
+        sources = []
+        for source in opts.sources:
+            sources.extend(source.split(','))
+
+        sources = sources or self.config['source'].as_str_seq()
+
+        meta_source_instances = {}
+        items = lib.items(query)
+
+        # Avoid needlessly instantiating meta sources (can be expensive)
+        if not items:
+            self._log.info(u'No items found matching query')
+            return
+
+        # Instantiate the meta sources
+        for player in sources:
+            try:
+                cls = META_SOURCES[player]
+            except KeyError:
+                self._log.error(u'Unknown metadata source \'{0}\''.format(
+                    player))
+
+            try:
+                meta_source_instances[player] = cls(self.config, self._log)
+            except (ImportError, ConfigValueError) as e:
+                self._log.error(u'Failed to instantiate metadata source '
+                                u'\'{0}\': {1}'.format(player, e))
+
+        # Avoid needlessly iterating over items
+        if not meta_source_instances:
+            self._log.error(u'No valid metadata sources found')
+            return
+
+        # Sync the items with all of the meta sources
+        for item in items:
+            for meta_source in meta_source_instances.values():
+                meta_source.sync_from_source(item)
+
+            changed = ui.show_model_changes(item)
+
+            if changed and not pretend:
+                item.store()

libs/common/beetsplug/metasync/amarok.py

@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*-
+# This file is part of beets.
+# Copyright 2016, Heinz Wiesinger.
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+
+"""Synchronize information from amarok's library via dbus
+"""
+
+from __future__ import division, absolute_import, print_function
+
+from os.path import basename
+from datetime import datetime
+from time import mktime
+from xml.sax.saxutils import quoteattr
+
+from beets.util import displayable_path
+from beets.dbcore import types
+from beets.library import DateType
+from beetsplug.metasync import MetaSource
+
+
+def import_dbus():
+    try:
+        return __import__('dbus')
+    except ImportError:
+        return None
+
+dbus = import_dbus()
+
+
+class Amarok(MetaSource):
+
+    item_types = {
+        'amarok_rating':      types.INTEGER,
+        'amarok_score':       types.FLOAT,
+        'amarok_uid':         types.STRING,
+        'amarok_playcount':   types.INTEGER,
+        'amarok_firstplayed': DateType(),
+        'amarok_lastplayed':  DateType(),
+    }
+
+    queryXML = u'<query version="1.0"> \
+                    <filters> \
+                        <and><include field="filename" value=%s /></and> \
+                    </filters> \
+                </query>'
+
+    def __init__(self, config, log):
+        super(Amarok, self).__init__(config, log)
+
+        if not dbus:
+            raise ImportError('failed to import dbus')
+
+        self.collection = \
+            dbus.SessionBus().get_object('org.kde.amarok', '/Collection')
+
+    def sync_from_source(self, item):
+        path = displayable_path(item.path)
+
+        # amarok unfortunately doesn't allow searching for the full path, only
+        # for the patch relative to the mount point. But the full path is part
+        # of the result set. So query for the filename and then try to match
+        # the correct item from the results we get back
+        results = self.collection.Query(
+            self.queryXML % quoteattr(basename(path))
+        )
+        for result in results:
+            if result['xesam:url'] != path:
+                continue
+
+            item.amarok_rating = result['xesam:userRating']
+            item.amarok_score = result['xesam:autoRating']
+            item.amarok_playcount = result['xesam:useCount']
+            item.amarok_uid = \
+                result['xesam:id'].replace('amarok-sqltrackuid://', '')
+
+            if result['xesam:firstUsed'][0][0] != 0:
+                # These dates are stored as timestamps in amarok's db, but
+                # exposed over dbus as fixed integers in the current timezone.
+                first_played = datetime(
+                    result['xesam:firstUsed'][0][0],
+                    result['xesam:firstUsed'][0][1],
+                    result['xesam:firstUsed'][0][2],
+                    result['xesam:firstUsed'][1][0],
+                    result['xesam:firstUsed'][1][1],
+                    result['xesam:firstUsed'][1][2]
+                )
+
+                if result['xesam:lastUsed'][0][0] != 0:
+                    last_played = datetime(
+                        result['xesam:lastUsed'][0][0],
+                        result['xesam:lastUsed'][0][1],
+                        result['xesam:lastUsed'][0][2],
+                        result['xesam:lastUsed'][1][0],
+                        result['xesam:lastUsed'][1][1],
+                        result['xesam:lastUsed'][1][2]
+                    )
+                else:
+                    last_played = first_played
+
+                item.amarok_firstplayed = mktime(first_played.timetuple())
+                item.amarok_lastplayed = mktime(last_played.timetuple())

libs/common/beetsplug/metasync/itunes.py

@@ -0,0 +1,121 @@
+# -*- coding: utf-8 -*-
+# This file is part of beets.
+# Copyright 2016, Tom Jaspers.
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+
+"""Synchronize information from iTunes's library
+"""
+
+from __future__ import division, absolute_import, print_function
+
+from contextlib import contextmanager
+import os
+import shutil
+import tempfile
+import plistlib
+
+from six.moves.urllib.parse import urlparse, unquote
+from time import mktime
+
+from beets import util
+from beets.dbcore import types
+from beets.library import DateType
+from beets.util.confit import ConfigValueError
+from beetsplug.metasync import MetaSource
+
+
+@contextmanager
+def create_temporary_copy(path):
+    temp_dir = tempfile.mkdtemp()
+    temp_path = os.path.join(temp_dir, 'temp_itunes_lib')
+    shutil.copyfile(path, temp_path)
+    try:
+        yield temp_path
+    finally:
+        shutil.rmtree(temp_dir)
+
+
+def _norm_itunes_path(path):
+    # Itunes prepends the location with 'file://' on posix systems,
+    # and with 'file://localhost/' on Windows systems.
+    # The actual path to the file is always saved as posix form
+    # E.g., 'file://Users/Music/bar' or 'file://localhost/G:/Music/bar'
+
+    # The entire path will also be capitalized (e.g., '/Music/Alt-J')
+    # Note that this means the path will always have a leading separator,
+    # which is unwanted in the case of Windows systems.
+    # E.g., '\\G:\\Music\\bar' needs to be stripped to 'G:\\Music\\bar'
+
+    return util.bytestring_path(os.path.normpath(
+        unquote(urlparse(path).path)).lstrip('\\')).lower()
+
+
+class Itunes(MetaSource):
+
+    item_types = {
+        'itunes_rating':      types.INTEGER,  # 0..100 scale
+        'itunes_playcount':   types.INTEGER,
+        'itunes_skipcount':   types.INTEGER,
+        'itunes_lastplayed':  DateType(),
+        'itunes_lastskipped': DateType(),
+    }
+
+    def __init__(self, config, log):
+        super(Itunes, self).__init__(config, log)
+
+        config.add({'itunes': {
+            'library': '~/Music/iTunes/iTunes Library.xml'
+        }})
+
+        # Load the iTunes library, which has to be the .xml one (not the .itl)
+        library_path = config['itunes']['library'].as_filename()
+
+        try:
+            self._log.debug(
+                u'loading iTunes library from {0}'.format(library_path))
+            with create_temporary_copy(library_path) as library_copy:
+                raw_library = plistlib.readPlist(library_copy)
+        except IOError as e:
+            raise ConfigValueError(u'invalid iTunes library: ' + e.strerror)
+        except Exception:
+            # It's likely the user configured their '.itl' library (<> xml)
+            if os.path.splitext(library_path)[1].lower() != '.xml':
+                hint = u': please ensure that the configured path' \
+                       u' points to the .XML library'
+            else:
+                hint = ''
+            raise ConfigValueError(u'invalid iTunes library' + hint)
+
+        # Make the iTunes library queryable using the path
+        self.collection = {_norm_itunes_path(track['Location']): track
+                           for track in raw_library['Tracks'].values()
+                           if 'Location' in track}
+
+    def sync_from_source(self, item):
+        result = self.collection.get(util.bytestring_path(item.path).lower())
+
+        if not result:
+            self._log.warning(u'no iTunes match found for {0}'.format(item))
+            return
+
+        item.itunes_rating = result.get('Rating')
+        item.itunes_playcount = result.get('Play Count')
+        item.itunes_skipcount = result.get('Skip Count')
+
+        if result.get('Play Date UTC'):
+            item.itunes_lastplayed = mktime(
+                result.get('Play Date UTC').timetuple())
+
+        if result.get('Skip Date'):
+            item.itunes_lastskipped = mktime(
+                result.get('Skip Date').timetuple())