pax_global_header00006660000000000000000000000064125046273500014516gustar00rootroot0000000000000052 comment=2083ce99300d53ba7fdd2704be4a305334e4528d mopidy-beets-2.0.0/000077500000000000000000000000001250462735000141165ustar00rootroot00000000000000mopidy-beets-2.0.0/.gitignore000066400000000000000000000004731250462735000161120ustar00rootroot00000000000000*.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 xunit-*.xml # Translations *.mo # Mr Developer .mr.developer.cfg .project .pydevproject mopidy-beets-2.0.0/.mailmap000066400000000000000000000001511250462735000155340ustar00rootroot00000000000000Janez Troha Janez Troha mopidy-beets-2.0.0/.travis.yml000066400000000000000000000012531250462735000162300ustar00rootroot00000000000000language: python python: - "2.7_with_system_site_packages" env: - TOX_ENV=py27 - TOX_ENV=flake8 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 mopidy-beets" - "pip install tox" script: - "tox -e $TOX_ENV" after_success: - "if [ $TOX_ENV == 'py27' ]; then pip install coveralls; coveralls; fi" branches: except: - debian notifications: irc: channels: - "irc.freenode.org#mopidy" on_success: change on_failure: change use_notice: true skip_join: true mopidy-beets-2.0.0/LICENSE000066400000000000000000000020571250462735000151270ustar00rootroot00000000000000Copyright (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-2.0.0/MANIFEST.in000066400000000000000000000002501250462735000156510ustar00rootroot00000000000000include .mailmap include .travis.yml include LICENSE include MANIFEST.in include README.rst include mopidy_beets/ext.conf include tox.ini recursive-include tests *.py mopidy-beets-2.0.0/README.rst000066400000000000000000000052131250462735000156060ustar00rootroot00000000000000************ Mopidy-Beets ************ .. image:: https://img.shields.io/pypi/v/Mopidy-Beets.svg?style=flat :target: https://pypi.python.org/pypi/Mopidy-Beets/ :alt: Latest PyPI version .. image:: https://img.shields.io/pypi/dm/Mopidy-Beets.svg?style=flat :target: https://pypi.python.org/pypi/Mopidy-Beets/ :alt: Number of PyPI downloads .. image:: https://img.shields.io/travis/mopidy/mopidy-beets/master.svg?style=flat :target: https://travis-ci.org/mopidy/mopidy-beets :alt: Travis CI build status .. image:: https://img.shields.io/coveralls/mopidy/mopidy-beets/master.svg?style=flat :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. Usage ===== #. Run ``beet web`` to start the Beets web interface. #. Start Mopidy, and search or browse your Beets library with any Mopidy client. Project resources ================= - `Source code `_ - `Issue tracker `_ - `Download development snapshot `_ Changelog ========= v2.0.0 (2015-03-25) ------------------- - Require Mopidy >= 1.0. - Update to work with new playback API in Mopidy 1.0. - Update to work with new backend search API in Mopidy 1.0. v1.1.0 (2014-01-20) ------------------- - Require Requests >= 2.0. - Updated extension and backend APIs to match Mopidy 0.18. 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-2.0.0/mopidy_beets/000077500000000000000000000000001250462735000166015ustar00rootroot00000000000000mopidy-beets-2.0.0/mopidy_beets/__init__.py000066400000000000000000000012711250462735000207130ustar00rootroot00000000000000from __future__ import unicode_literals import os from mopidy import config, ext __version__ = '2.0.0' 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 setup(self, registry): from .actor import BeetsBackend registry.add('backend', BeetsBackend) mopidy-beets-2.0.0/mopidy_beets/actor.py000066400000000000000000000020101250462735000202540ustar00rootroot00000000000000from __future__ import unicode_literals import logging from mopidy import backend import pykka from .client import BeetsRemoteClient from .library import BeetsLibraryProvider logger = logging.getLogger(__name__) class BeetsBackend(pykka.ThreadingActor, backend.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(backend.PlaybackProvider): def translate_uri(self, uri): track_id = uri.split(';')[1] logger.debug('Getting info for track %s with id %s' % (uri, track_id)) track = self.backend.beets_api.get_track(track_id, True) return track.uri mopidy-beets-2.0.0/mopidy_beets/client.py000066400000000000000000000127601250462735000204370ustar00rootroot00000000000000from __future__ import unicode_literals import logging import time import urllib from mopidy.models import Album, Artist, Track import requests from requests.exceptions import RequestException logger = logging.getLogger(__name__) 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-2.0.0/mopidy_beets/ext.conf000066400000000000000000000000701250462735000202450ustar00rootroot00000000000000[beets] enabled = true hostname = 127.0.0.1 port = 8888 mopidy-beets-2.0.0/mopidy_beets/library.py000066400000000000000000000042321250462735000206200ustar00rootroot00000000000000from __future__ import unicode_literals import logging from mopidy import backend from mopidy.models import SearchResult logger = logging.getLogger(__name__) class BeetsLibraryProvider(backend.LibraryProvider): def __init__(self, *args, **kwargs): super(BeetsLibraryProvider, self).__init__(*args, **kwargs) self.remote = self.backend.beets_api def search(self, query=None, uris=None, exact=False): # TODO Support exact search 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-2.0.0/setup.cfg000066400000000000000000000001421250462735000157340ustar00rootroot00000000000000[flake8] application-import-names = mopidy_beets,tests exclude = .git,.tox [wheel] universal = 1 mopidy-beets-2.0.0/setup.py000066400000000000000000000023501250462735000156300ustar00rootroot00000000000000from __future__ import unicode_literals import re from setuptools import find_packages, setup def get_version(filename): with open(filename) as fh: metadata = dict(re.findall("__([a-z]+)__ = '([^']+)'", fh.read())) 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 >= 1.0', 'Pykka >= 1.1', 'requests >= 2.0.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-2.0.0/tests/000077500000000000000000000000001250462735000152605ustar00rootroot00000000000000mopidy-beets-2.0.0/tests/__init__.py000066400000000000000000000000001250462735000173570ustar00rootroot00000000000000mopidy-beets-2.0.0/tests/test_extension.py000066400000000000000000000013021250462735000207010ustar00rootroot00000000000000from __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 mopidy-beets-2.0.0/tox.ini000066400000000000000000000007461250462735000154400ustar00rootroot00000000000000[tox] envlist = py27, flake8 [testenv] sitepackages = true deps = mock mopidy==dev pytest pytest-cov pytest-xdist install_command = pip install --allow-unverified=mopidy --pre {opts} {packages} commands = py.test \ --basetemp={envtmpdir} \ --junit-xml=xunit-{envname}.xml \ --cov=mopidy_beets --cov-report=term-missing \ {posargs} [testenv:flake8] deps = flake8 flake8-import-order skip_install = true commands = flake8