pax_global_header00006660000000000000000000000064122534033650014515gustar00rootroot0000000000000052 comment=5dde69cf38e41f5bf37cb2b1b5df8f880eb158dc mopidy-beets-1.0.4/000077500000000000000000000000001225340336500141205ustar00rootroot00000000000000mopidy-beets-1.0.4/.gitignore000066400000000000000000000004571225340336500161160ustar00rootroot00000000000000*.py[cod] # C extensions *.so # Packages *.egg *.egg-info dist build eggs parts bin var sdist develop-eggs .installed.cfg lib lib64 # Installer logs pip-log.txt # Unit test / coverage reports .coverage .tox nosetests.xml # Translations *.mo # Mr Developer .mr.developer.cfg .project .pydevproject mopidy-beets-1.0.4/.travis.yml000066400000000000000000000014071225340336500162330ustar00rootroot00000000000000language: python install: - "wget -O - http://apt.mopidy.com/mopidy.gpg | sudo apt-key add -" - "sudo wget -O /etc/apt/sources.list.d/mopidy.list http://apt.mopidy.com/mopidy.list" - "sudo apt-get update || true" - "sudo apt-get install $(apt-cache depends mopidy-beets | awk '$2 !~ /mopidy-beets|python:any/ {print $2}')" - "pip install coveralls flake8 mopidy==dev" before_script: - "rm $VIRTUAL_ENV/lib/python$TRAVIS_PYTHON_VERSION/no-global-site-packages.txt" script: - "flake8 $(find . -iname '*.py')" - "nosetests --with-coverage --cover-package=mopidy_beets" after_success: - "coveralls" notifications: irc: channels: - "irc.freenode.org#mopidy" on_success: change on_failure: change use_notice: true skip_join: true mopidy-beets-1.0.4/LICENSE000066400000000000000000000020571225340336500151310ustar00rootroot00000000000000Copyright (C) 2013 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. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.mopidy-beets-1.0.4/MANIFEST.in000066400000000000000000000001251225340336500156540ustar00rootroot00000000000000include LICENSE include MANIFEST.in include README.rst include mopidy_beets/ext.conf mopidy-beets-1.0.4/Makefile000066400000000000000000000012061225340336500155570ustar00rootroot00000000000000.PHONY: clean-pyc clean-build docs help: @echo "clean-build - remove build artifacts" @echo "clean-pyc - remove Python file artifacts" @echo "test - run tests quickly with the default Python" @echo "release - package and upload a release" @echo "sdist - package" clean: clean-build clean-pyc clean-build: rm -fr build/ rm -fr dist/ rm -fr *.egg-info clean-pyc: find . -name '*.pyc' -exec rm -f {} + find . -name '*.pyo' -exec rm -f {} + find . -name '*~' -exec rm -f {} + lint: flake8 mopidy_beets -v --count --show-source test: lint release: clean python setup.py sdist upload sdist: clean python setup.py sdist ls -l distmopidy-beets-1.0.4/README.rst000066400000000000000000000042111225340336500156050ustar00rootroot00000000000000************ Mopidy-Beets ************ .. image:: https://pypip.in/v/Mopidy-Beets/badge.png :target: https://crate.io/packages/Mopidy-Beets/ :alt: Latest PyPI version .. image:: https://pypip.in/d/Mopidy-Beets/badge.png :target: https://crate.io/packages/Mopidy-Beets/ :alt: Number of PyPI downloads .. image:: https://travis-ci.org/mopidy/mopidy-beets.png?branch=master :target: https://travis-ci.org/mopidy/mopidy-beets :alt: Travis CI build status .. image:: https://coveralls.io/repos/mopidy/mopidy-beets/badge.png?branch=master :target: https://coveralls.io/r/mopidy/mopidy-beets?branch=master :alt: Test coverage `Mopidy `_ extension for playing music from `Beets `_ via Beets' web extension. Installation ============ Install by running:: pip install Mopidy-Beets Or, if available, install the Debian/Ubuntu package from `apt.mopidy.com `_. Configuration ============= #. Setup the `Beets web plugin `_. #. Tell Mopidy where to find the Beets web interface by adding the following to your ``mopidy.conf``:: [beets] hostname = 127.0.0.1 port = 8888 #. Restart Mopidy. #. Searches in Mopidy will now return results from your Beets library. Project resources ================= - `Source code `_ - `Issue tracker `_ - `Download development snapshot `_ Changelog ========= v1.0.4 (2013-12-15) ------------------- - Require Requests >= 1.0, as 0.x does not seem to be enough. (Fixes: #7) - Remove hacks for Python 2.6 compatibility. - Change search field ``track`` to ``track_name`` for compatibility with Mopidy 0.17. (Fixes: mopidy/mopidy#610) v1.0.3 (2013-11-02) ------------------- - Properly encode search queries containing non-ASCII chars. - Rename logger to ``mopidy_beets``. v1.0.2 (2013-04-30) ------------------- - Fix search. v1.0.1 (2013-04-28) ------------------- - Initial release. mopidy-beets-1.0.4/mopidy_beets/000077500000000000000000000000001225340336500166035ustar00rootroot00000000000000mopidy-beets-1.0.4/mopidy_beets/__init__.py000066400000000000000000000016231225340336500207160ustar00rootroot00000000000000from __future__ import unicode_literals import os from mopidy import ext, config from mopidy.exceptions import ExtensionError __version__ = '1.0.4' class BeetsExtension(ext.Extension): dist_name = 'Mopidy-Beets' ext_name = 'beets' version = __version__ def get_default_config(self): conf_file = os.path.join(os.path.dirname(__file__), 'ext.conf') return config.read(conf_file) def get_config_schema(self): schema = super(BeetsExtension, self).get_config_schema() schema['hostname'] = config.Hostname() schema['port'] = config.Port() return schema def validate_environment(self): try: import requests # noqa except ImportError as e: raise ExtensionError('Library requests not found', e) def get_backend_classes(self): from .actor import BeetsBackend return [BeetsBackend] mopidy-beets-1.0.4/mopidy_beets/actor.py000066400000000000000000000020471225340336500202700ustar00rootroot00000000000000from __future__ import unicode_literals import logging import pykka from mopidy.backends import base from .library import BeetsLibraryProvider from .client import BeetsRemoteClient logger = logging.getLogger('mopidy_beets') class BeetsBackend(pykka.ThreadingActor, base.Backend): def __init__(self, config, audio): super(BeetsBackend, self).__init__() beets_endpoint = 'http://%s:%s' % ( config['beets']['hostname'], config['beets']['port']) self.beets_api = BeetsRemoteClient(beets_endpoint) self.library = BeetsLibraryProvider(backend=self) self.playback = BeetsPlaybackProvider(audio=audio, backend=self) self.playlists = None self.uri_schemes = ['beets'] class BeetsPlaybackProvider(base.BasePlaybackProvider): def play(self, track): id = track.uri.split(';')[1] logger.info('Getting info for track %s with id %s' % (track.uri, id)) track = self.backend.beets_api.get_track(id, True) return super(BeetsPlaybackProvider, self).play(track) mopidy-beets-1.0.4/mopidy_beets/client.py000066400000000000000000000127731225340336500204450ustar00rootroot00000000000000from __future__ import unicode_literals import logging import requests import time import urllib from requests.exceptions import RequestException from mopidy.models import Track, Album, Artist logger = logging.getLogger('mopidy_beets.client') class cache(object): # TODO: merge this to util library def __init__(self, ctl=8, ttl=3600): self.cache = {} self.ctl = ctl self.ttl = ttl self._call_count = 1 def __call__(self, func): def _memoized(*args): self.func = func now = time.time() try: value, last_update = self.cache[args] age = now - last_update if self._call_count >= self.ctl or \ age > self.ttl: self._call_count = 1 raise AttributeError self._call_count += 1 return value except (KeyError, AttributeError): value = self.func(*args) self.cache[args] = (value, now) return value except TypeError: return self.func(*args) return _memoized class BeetsRemoteClient(object): def __init__(self, endpoint): super(BeetsRemoteClient, self).__init__() self.api = requests.Session() self.has_connection = False self.api_endpoint = endpoint logger.info('Connecting to Beets remote library %s', endpoint) try: self.api.get(self.api_endpoint) self.has_connection = True except RequestException as e: logger.error('Beets error: %s' % e) @cache() def get_tracks(self): track_ids = self._get('/item/').get('item_ids') tracks = [] for track_id in track_ids: tracks.append(self.get_track(track_id)) return tracks @cache(ctl=16) def get_track(self, id, remote_url=False): return self._convert_json_data(self._get('/item/%s' % id), remote_url) @cache() def get_item_by(self, name): if isinstance(name, unicode): name = name.encode('utf-8') res = self._get('/item/query/%s' % urllib.quote(name)).get('results') try: return self._parse_query(res) except Exception: return False @cache() def get_album_by(self, name): if isinstance(name, unicode): name = name.encode('utf-8') res = self._get('/album/query/%s' % urllib.quote(name)).get('results') try: return self._parse_query(res[0]['items']) except Exception: return False def _get(self, url): try: url = self.api_endpoint + url logger.debug('Requesting %s' % url) req = self.api.get(url) if req.status_code != 200: raise logger.error('Request %s, failed with status code %s' % ( url, req.status_code)) return req.json() except Exception as e: return False logger.error('Request %s, failed with error %s' % ( url, e)) def _parse_query(self, res): if len(res) > 0: tracks = [] for track in res: tracks.append(self._convert_json_data(track)) return tracks return None def _convert_json_data(self, data, remote_url=False): if not data: return track_kwargs = {} album_kwargs = {} artist_kwargs = {} albumartist_kwargs = {} if 'track' in data: track_kwargs['track_no'] = int(data['track']) if 'tracktotal' in data: album_kwargs['num_tracks'] = int(data['tracktotal']) if 'artist' in data: artist_kwargs['name'] = data['artist'] albumartist_kwargs['name'] = data['artist'] if 'albumartist' in data: albumartist_kwargs['name'] = data['albumartist'] if 'album' in data: album_kwargs['name'] = data['album'] if 'title' in data: track_kwargs['name'] = data['title'] if 'date' in data: track_kwargs['date'] = data['date'] if 'mb_trackid' in data: track_kwargs['musicbrainz_id'] = data['mb_trackid'] if 'mb_albumid' in data: album_kwargs['musicbrainz_id'] = data['mb_albumid'] if 'mb_artistid' in data: artist_kwargs['musicbrainz_id'] = data['mb_artistid'] if 'mb_albumartistid' in data: albumartist_kwargs['musicbrainz_id'] = ( data['mb_albumartistid']) if 'album_id' in data: album_art_url = '%s/album/%s/art' % ( self.api_endpoint, data['album_id']) album_kwargs['images'] = [album_art_url] if artist_kwargs: artist = Artist(**artist_kwargs) track_kwargs['artists'] = [artist] if albumartist_kwargs: albumartist = Artist(**albumartist_kwargs) album_kwargs['artists'] = [albumartist] if album_kwargs: album = Album(**album_kwargs) track_kwargs['album'] = album if remote_url: track_kwargs['uri'] = '%s/item/%s/file' % ( self.api_endpoint, data['id']) else: track_kwargs['uri'] = 'beets:track;%s' % data['id'] track_kwargs['length'] = int(data.get('length', 0)) * 1000 track = Track(**track_kwargs) return track mopidy-beets-1.0.4/mopidy_beets/ext.conf000066400000000000000000000000701225340336500202470ustar00rootroot00000000000000[beets] enabled = true hostname = 127.0.0.1 port = 8888 mopidy-beets-1.0.4/mopidy_beets/library.py000066400000000000000000000043351225340336500206260ustar00rootroot00000000000000from __future__ import unicode_literals import logging from mopidy.backends import base from mopidy.models import SearchResult logger = logging.getLogger('mopidy_beets') class BeetsLibraryProvider(base.BaseLibraryProvider): def __init__(self, *args, **kwargs): super(BeetsLibraryProvider, self).__init__(*args, **kwargs) self.remote = self.backend.beets_api def find_exact(self, query=None, uris=None): return self.search(query=query, uris=uris) def search(self, query=None, uris=None): logger.debug('Query "%s":' % query) if not self.remote.has_connection: return [] if not query: # Fetch all data(browse library) return SearchResult( uri='beets:search', tracks=self.remote.get_tracks()) self._validate_query(query) if 'any' in query: return SearchResult( uri='beets:search-any', tracks=self.remote.get_item_by(query['any'][0]) or []) else: search = [] for (field, val) in query.iteritems(): if field == "album": search.append(val[0]) if field == "artist": search.append(val[0]) if field == "track_name": search.append(val[0]) if field == "date": search.append(val[0]) logger.debug('Search query "%s":' % search) return SearchResult( uri='beets:search-' + '-'.join(search), tracks=self.remote.get_item_by('/'.join(search)) or []) def lookup(self, uri): try: id = uri.split(";")[1] logger.debug('Beets track id for "%s": %s' % (id, uri)) return [self.remote.get_track(id, True)] except Exception as error: logger.debug('Failed to lookup "%s": %s' % (uri, error)) return [] def _validate_query(self, query): for (_, values) in query.iteritems(): if not values: raise LookupError('Missing query') for value in values: if not value: raise LookupError('Missing query') mopidy-beets-1.0.4/setup.py000066400000000000000000000023421225340336500156330ustar00rootroot00000000000000from __future__ import unicode_literals import re from setuptools import setup, find_packages def get_version(filename): content = open(filename).read() metadata = dict(re.findall("__([a-z]+)__ = '([^']+)'", content)) return metadata['version'] setup( name='Mopidy-Beets', version=get_version('mopidy_beets/__init__.py'), url='https://github.com/mopidy/mopidy-beets', license='MIT', author='dz0ny', author_email='dz0ny@shortmail.com', description='Beets extension for Mopidy', long_description=open('README.rst').read(), packages=find_packages(exclude=['tests', 'tests.*']), zip_safe=False, include_package_data=True, install_requires=[ 'setuptools', 'Mopidy >= 0.17', 'Pykka >= 1.1', 'requests >= 1.0', ], entry_points={ b'mopidy.ext': [ 'beets = mopidy_beets:BeetsExtension', ], }, classifiers=[ 'Environment :: No Input/Output (Daemon)', 'Intended Audience :: End Users/Desktop', 'License :: OSI Approved :: MIT License', 'Operating System :: OS Independent', 'Programming Language :: Python :: 2', 'Topic :: Multimedia :: Sound/Audio :: Players', ], ) mopidy-beets-1.0.4/tests/000077500000000000000000000000001225340336500152625ustar00rootroot00000000000000mopidy-beets-1.0.4/tests/__init__.py000066400000000000000000000000001225340336500173610ustar00rootroot00000000000000mopidy-beets-1.0.4/tests/test_extension.py000066400000000000000000000013021225340336500207030ustar00rootroot00000000000000from __future__ import unicode_literals import unittest from mopidy_beets import BeetsExtension class ExtensionTest(unittest.TestCase): def test_get_default_config(self): ext = BeetsExtension() config = ext.get_default_config() self.assertIn('[beets]', config) self.assertIn('enabled = true', config) self.assertIn('hostname = 127.0.0.1', config) self.assertIn('port = 8888', config) def test_get_config_schema(self): ext = BeetsExtension() schema = ext.get_config_schema() self.assertIn('enabled', schema) self.assertIn('hostname', schema) self.assertIn('port', schema) # TODO Write more tests