diff --git a/docs/changes.rst b/docs/changes.rst index f8f2d402..ce011d9b 100644 --- a/docs/changes.rst +++ b/docs/changes.rst @@ -18,11 +18,19 @@ v0.8 (in development) Track position and CPID was intermixed, so it would cause a crash if a CPID matching the track position didn't exist. (Fixes: :issue:`162`) -- Removed most traces of multiple outputs support. Having this feature - currently seems to be more trouble than what it is worth. - :attr:`mopidy.settings.OUTPUTS` setting is no longer supported, and has been - replaced with :attr:`mopidy.settings.OUTPUT` which is a GStreamer - bin described in the same format as ``gst-launch`` expects. Default value is +- Added :option:`--list-deps` option to :cmd:`mopidy` command that lists + required and optional dependencies, their current versions, and some other + information useful for debugging. (Fixes: :issue:`74`) + +- When unknown settings are encountered, we now check if it's similar to a + known setting, and suggests to the user what we think the setting should have + been. + +- Removed multiple outputs support. Having this feature currently seems to be + more trouble than what it is worth. The :attr:`mopidy.settings.OUTPUTS` + setting is no longer supported, and has been replaced with + :attr:`mopidy.settings.OUTPUT` which is a GStreamer bin description string in + the same format as ``gst-launch`` expects. Default value is ``autoaudiosink``. diff --git a/docs/settings.rst b/docs/settings.rst index 2f0f0f12..94f3c63b 100644 --- a/docs/settings.rst +++ b/docs/settings.rst @@ -157,13 +157,13 @@ server simultaneously. To use the SHOUTcast output, do the following: #. Install, configure and start the Icecast server. It can be found in the ``icecast2`` package in Debian/Ubuntu. -#. Set :attr:`mopidy.settings.OUTPUT` to ``lame ! shout2send`` (an Ogg Vorbis - encoder could be used instead of lame). +#. Set :attr:`mopidy.settings.OUTPUT` to ``lame ! shout2send``. An Ogg Vorbis + encoder could be used instead of the lame MP3 encoder. #. You might also need to change the ``shout2send`` default settings, run ``gst-inspect-0.10 shout2send`` to see the available settings. Most likely - you want to change ``ip``, ``username``, ``password`` and ``mount``. For - example, to set the password use: + you want to change ``ip``, ``username``, ``password``, and ``mount``. For + example, to set the username and password, use: ``lame ! shout2send username="foobar" password="s3cret"``. Other advanced setups are also possible for outputs. Basically anything you can diff --git a/mopidy/core.py b/mopidy/core.py index 128b4723..7d2e01ff 100644 --- a/mopidy/core.py +++ b/mopidy/core.py @@ -22,6 +22,7 @@ from mopidy import (get_version, settings, OptionalDependencyError, SettingsError, DATA_PATH, SETTINGS_PATH, SETTINGS_FILE) from mopidy.gstreamer import GStreamer from mopidy.utils import get_class +from mopidy.utils.deps import list_deps_optparse_callback from mopidy.utils.log import setup_logging from mopidy.utils.path import get_or_create_folder, get_or_create_file from mopidy.utils.process import (exit_handler, stop_remaining_actors, @@ -77,6 +78,9 @@ def parse_options(): parser.add_option('--list-settings', action='callback', callback=list_settings_optparse_callback, help='list current settings') + parser.add_option('--list-deps', + action='callback', callback=list_deps_optparse_callback, + help='list dependencies and their versions') return parser.parse_args(args=mopidy_args)[0] def check_old_folders(): diff --git a/mopidy/frontends/mpd/protocol/music_db.py b/mopidy/frontends/mpd/protocol/music_db.py index cde2754a..da8de91e 100644 --- a/mopidy/frontends/mpd/protocol/music_db.py +++ b/mopidy/frontends/mpd/protocol/music_db.py @@ -196,7 +196,7 @@ def _list_build_query(field, mpd_query): if error.message == 'No closing quotation': raise MpdArgError(u'Invalid unquoted character', command=u'list') else: - raise error + raise tokens = [t.decode('utf-8') for t in tokens] if len(tokens) == 1: if field == u'album': diff --git a/mopidy/gstreamer.py b/mopidy/gstreamer.py index 4eb94e91..2fbf6189 100644 --- a/mopidy/gstreamer.py +++ b/mopidy/gstreamer.py @@ -151,7 +151,6 @@ class FakeMixer(gst.Element, gst.ImplementsInterface, gst.interfaces.Mixer): def set_record(self, track, record): pass - gobject.type_register(FakeMixer) gst.element_register (FakeMixer, 'fakemixer', gst.RANK_MARGINAL) diff --git a/mopidy/utils/deps.py b/mopidy/utils/deps.py new file mode 100644 index 00000000..2c68e429 --- /dev/null +++ b/mopidy/utils/deps.py @@ -0,0 +1,193 @@ +import os +import platform +import sys + +import pygst +pygst.require('0.10') +import gst + +import pykka + +from mopidy.utils.log import indent + + +def list_deps_optparse_callback(*args): + """ + Prints a list of all dependencies. + + Called by optparse when Mopidy is run with the :option:`--list-deps` + option. + """ + print format_dependency_list() + sys.exit(0) + + +def format_dependency_list(adapters=None): + if adapters is None: + adapters = [ + platform_info, + python_info, + gstreamer_info, + pykka_info, + pyspotify_info, + pylast_info, + dbus_info, + serial_info, + ] + + lines = [] + for adapter in adapters: + dep_info = adapter() + lines.append('%(name)s: %(version)s' % { + 'name': dep_info['name'], + 'version': dep_info.get('version', 'not found'), + }) + if 'path' in dep_info: + lines.append(' Imported from: %s' % ( + os.path.dirname(dep_info['path']))) + if 'other' in dep_info: + lines.append(' Other: %s' % ( + indent(dep_info['other'])),) + return '\n'.join(lines) + + +def platform_info(): + return { + 'name': 'Platform', + 'version': platform.platform(), + } + + +def python_info(): + return { + 'name': 'Python', + 'version': '%s %s' % (platform.python_implementation(), + platform.python_version()), + 'path': platform.__file__, + } + + +def gstreamer_info(): + other = [] + other.append('Python wrapper: gst-python %s' % ( + '.'.join(map(str, gst.get_pygst_version())))) + other.append('Relevant elements:') + for name, status in _gstreamer_check_elements(): + other.append(' %s: %s' % (name, 'OK' if status else 'not found')) + return { + 'name': 'GStreamer', + 'version': '.'.join(map(str, gst.get_gst_version())), + 'path': gst.__file__, + 'other': '\n'.join(other), + } + + +def _gstreamer_check_elements(): + elements_to_check = [ + # Core playback + 'uridecodebin', + + # External HTTP streams + 'souphttpsrc', + + # Spotify + 'appsrc', + + # Mixers and sinks + 'alsamixer', + 'alsasink', + 'ossmixer', + 'osssink', + 'oss4mixer', + 'oss4sink', + 'pulsemixer', + 'pulsesink', + + # MP3 encoding and decoding + 'mp3parse', + 'mad', + 'id3demux', + 'id3v2mux', + 'lame', + + # Ogg Vorbis encoding and decoding + 'vorbisdec', + 'vorbisenc', + 'vorbisparse', + 'oggdemux', + 'oggmux', + 'oggparse', + + # Flac decoding + 'flacdec', + 'flacparse', + + # Shoutcast output + 'shout2send', + ] + known_elements = [factory.get_name() for factory in + gst.registry_get_default().get_feature_list(gst.TYPE_ELEMENT_FACTORY)] + return [(element, element in known_elements) for element in elements_to_check] + + +def pykka_info(): + if hasattr(pykka, '__version__'): + # Pykka >= 0.14 + version = pykka.__version__ + else: + # Pykka < 0.14 + version = pykka.get_version() + return { + 'name': 'Pykka', + 'version': version, + 'path': pykka.__file__, + } + + +def pyspotify_info(): + dep_info = {'name': 'pyspotify'} + try: + import spotify + if hasattr(spotify, '__version__'): + dep_info['version'] = spotify.__version__ + else: + dep_info['version'] = '< 1.3' + dep_info['path'] = spotify.__file__ + dep_info['other'] = 'Built for libspotify API version %d' % ( + spotify.api_version,) + except ImportError: + pass + return dep_info + + +def pylast_info(): + dep_info = {'name': 'pylast'} + try: + import pylast + dep_info['version'] = pylast.__version__ + dep_info['path'] = pylast.__file__ + except ImportError: + pass + return dep_info + + +def dbus_info(): + dep_info = {'name': 'dbus-python'} + try: + import dbus + dep_info['version'] = dbus.__version__ + dep_info['path'] = dbus.__file__ + except ImportError: + pass + return dep_info + + +def serial_info(): + dep_info = {'name': 'pyserial'} + try: + import serial + dep_info['version'] = serial.VERSION + dep_info['path'] = serial.__file__ + except ImportError: + pass + return dep_info diff --git a/mopidy/utils/settings.py b/mopidy/utils/settings.py index 70d45721..edda0222 100644 --- a/mopidy/utils/settings.py +++ b/mopidy/utils/settings.py @@ -12,6 +12,7 @@ from mopidy.utils.log import indent logger = logging.getLogger('mopidy.utils.settings') + class SettingsProxy(object): def __init__(self, default_settings_module): self.default = self._get_settings_dict_from_module( @@ -101,7 +102,7 @@ def validate_settings(defaults, settings): Checks the settings for both errors like misspellings and against a set of rules for renamed settings, etc. - Returns of setting names with associated errors. + Returns mapping from setting names to associated errors. :param defaults: Mopidy's default settings :type defaults: dict @@ -116,9 +117,9 @@ def validate_settings(defaults, settings): 'DUMP_LOG_FILENAME': 'DEBUG_LOG_FILENAME', 'DUMP_LOG_FORMAT': 'DEBUG_LOG_FORMAT', 'FRONTEND': 'FRONTENDS', - 'GSTREAMER_AUDIO_SINK': 'CUSTOM_OUTPUT', + 'GSTREAMER_AUDIO_SINK': 'OUTPUT', 'LOCAL_MUSIC_FOLDER': 'LOCAL_MUSIC_PATH', - 'LOCAL_OUTPUT_OVERRIDE': 'CUSTOM_OUTPUT', + 'LOCAL_OUTPUT_OVERRIDE': 'OUTPUT', 'LOCAL_PLAYLIST_FOLDER': 'LOCAL_PLAYLIST_PATH', 'LOCAL_TAG_CACHE': 'LOCAL_TAG_CACHE_FILE', 'MIXER_ALSA_CONTROL': None, @@ -152,7 +153,7 @@ def validate_settings(defaults, settings): elif setting == 'OUTPUTS': errors[setting] = ( u'Deprecated setting, please change to OUTPUT. OUTPUT expectes ' - u'a GStreamer bin describing your desired output.') + u'a GStreamer bin description string for your desired output.') elif setting == 'SPOTIFY_BITRATE': if value not in (96, 160, 320): @@ -166,11 +167,15 @@ def validate_settings(defaults, settings): u'bin in OUTPUT.') elif setting not in defaults: - errors[setting] = u'Unknown setting. Is it misspelled?' - continue + errors[setting] = u'Unknown setting.' + suggestion = did_you_mean(setting, defaults) + + if suggestion: + errors[setting] += u' Did you mean %s?' % suggestion return errors + def list_settings_optparse_callback(*args): """ Prints a list of all settings. @@ -182,6 +187,7 @@ def list_settings_optparse_callback(*args): print format_settings_list(settings) sys.exit(0) + def format_settings_list(settings): errors = settings.get_errors() lines = [] @@ -196,8 +202,41 @@ def format_settings_list(settings): lines.append(u' Error: %s' % errors[key]) return '\n'.join(lines) + def mask_value_if_secret(key, value): if key.endswith('PASSWORD') and value: return u'********' else: return value + + +def did_you_mean(setting, defaults): + """Suggest most likely setting based on levenshtein.""" + if not defaults: + return None + + setting = setting.upper() + candidates = [(levenshtein(setting, d), d) for d in defaults] + candidates.sort() + + if candidates[0][0] <= 3: + return candidates[0][1] + return None + + +def levenshtein(a, b, max=3): + """Calculates the Levenshtein distance between a and b.""" + n, m = len(a), len(b) + if n > m: + return levenshtein(b, a) + + current = xrange(n+1) + for i in xrange(1, m+1): + previous, current = current, [i] + [0] * n + for j in xrange(1, n+1): + add, delete = previous[j] + 1, current[j-1] + 1 + change = previous[j-1] + if a[j-1] != b[i-1]: + change += 1 + current[j] = min(add, delete, change) + return current[n] diff --git a/tests/utils/deps_test.py b/tests/utils/deps_test.py new file mode 100644 index 00000000..f5aa0b1e --- /dev/null +++ b/tests/utils/deps_test.py @@ -0,0 +1,113 @@ +import platform + +import pygst +pygst.require('0.10') +import gst +import pykka + +try: + import dbus +except ImportError: + dbus = False + +try: + import pylast +except ImportError: + pylast = False + +try: + import serial +except ImportError: + serial = False + +try: + import spotify +except ImportError: + spotify = False + +from mopidy.utils import deps + +from tests import unittest + + +class DepsTest(unittest.TestCase): + def test_format_dependency_list(self): + adapters = [ + lambda: dict(name='Python', version='FooPython 2.7.3'), + lambda: dict(name='Platform', version='Loonix 4.0.1'), + lambda: dict(name='Pykka', path='/foo/bar/baz.py', other='Quux') + ] + + result = deps.format_dependency_list(adapters) + + self.assertIn('Python: FooPython 2.7.3', result) + self.assertIn('Platform: Loonix 4.0.1', result) + self.assertIn('Pykka: not found', result) + self.assertIn('Imported from: /foo/bar', result) + self.assertNotIn('/baz.py', result) + self.assertIn('Quux', result) + + def test_platform_info(self): + result = deps.platform_info() + + self.assertEquals('Platform', result['name']) + self.assertIn(platform.platform(), result['version']) + + def test_python_info(self): + result = deps.python_info() + + self.assertEquals('Python', result['name']) + self.assertIn(platform.python_implementation(), result['version']) + self.assertIn(platform.python_version(), result['version']) + self.assertIn('python', result['path']) + + def test_gstreamer_info(self): + result = deps.gstreamer_info() + + self.assertEquals('GStreamer', result['name']) + self.assertEquals('.'.join(map(str, gst.get_gst_version())), result['version']) + self.assertIn('gst', result['path']) + self.assertIn('Python wrapper: gst-python', result['other']) + self.assertIn('.'.join(map(str, gst.get_pygst_version())), result['other']) + self.assertIn('Relevant elements:', result['other']) + + def test_pykka_info(self): + result = deps.pykka_info() + + self.assertEquals('Pykka', result['name']) + self.assertEquals(pykka.__version__, result['version']) + self.assertIn('pykka', result['path']) + + @unittest.skipUnless(spotify, 'pyspotify not found') + def test_pyspotify_info(self): + result = deps.pyspotify_info() + + self.assertEquals('pyspotify', result['name']) + self.assertEquals(spotify.__version__, result['version']) + self.assertIn('spotify', result['path']) + self.assertIn('Built for libspotify API version', result['other']) + self.assertIn(str(spotify.api_version), result['other']) + + @unittest.skipUnless(pylast, 'pylast not found') + def test_pylast_info(self): + result = deps.pylast_info() + + self.assertEquals('pylast', result['name']) + self.assertEquals(pylast.__version__, result['version']) + self.assertIn('pylast', result['path']) + + @unittest.skipUnless(dbus, 'dbus not found') + def test_dbus_info(self): + result = deps.dbus_info() + + self.assertEquals('dbus-python', result['name']) + self.assertEquals(dbus.__version__, result['version']) + self.assertIn('dbus', result['path']) + + @unittest.skipUnless(serial, 'serial not found') + def test_serial_info(self): + result = deps.serial_info() + + self.assertEquals('pyserial', result['name']) + self.assertEquals(serial.VERSION, result['version']) + self.assertIn('serial', result['path']) diff --git a/tests/utils/settings_test.py b/tests/utils/settings_test.py index 55e1156b..7d104969 100644 --- a/tests/utils/settings_test.py +++ b/tests/utils/settings_test.py @@ -1,8 +1,7 @@ import os -from mopidy import settings as default_settings_module, SettingsError -from mopidy.utils.settings import (format_settings_list, mask_value_if_secret, - SettingsProxy, validate_settings) +import mopidy +from mopidy.utils import settings as setting_utils from tests import unittest @@ -16,29 +15,29 @@ class ValidateSettingsTest(unittest.TestCase): } def test_no_errors_yields_empty_dict(self): - result = validate_settings(self.defaults, {}) + result = setting_utils.validate_settings(self.defaults, {}) self.assertEqual(result, {}) def test_unknown_setting_returns_error(self): - result = validate_settings(self.defaults, + result = setting_utils.validate_settings(self.defaults, {'MPD_SERVER_HOSTNMAE': '127.0.0.1'}) self.assertEqual(result['MPD_SERVER_HOSTNMAE'], - u'Unknown setting. Is it misspelled?') + u'Unknown setting. Did you mean MPD_SERVER_HOSTNAME?') def test_not_renamed_setting_returns_error(self): - result = validate_settings(self.defaults, + result = setting_utils.validate_settings(self.defaults, {'SERVER_HOSTNAME': '127.0.0.1'}) self.assertEqual(result['SERVER_HOSTNAME'], u'Deprecated setting. Use MPD_SERVER_HOSTNAME.') def test_unneeded_settings_returns_error(self): - result = validate_settings(self.defaults, + result = setting_utils.validate_settings(self.defaults, {'SPOTIFY_LIB_APPKEY': '/tmp/foo'}) self.assertEqual(result['SPOTIFY_LIB_APPKEY'], u'Deprecated setting. It may be removed.') def test_deprecated_setting_value_returns_error(self): - result = validate_settings(self.defaults, + result = setting_utils.validate_settings(self.defaults, {'BACKENDS': ('mopidy.backends.despotify.DespotifyBackend',)}) self.assertEqual(result['BACKENDS'], u'Deprecated setting value. ' + @@ -46,33 +45,33 @@ class ValidateSettingsTest(unittest.TestCase): 'available.') def test_unavailable_bitrate_setting_returns_error(self): - result = validate_settings(self.defaults, + result = setting_utils.validate_settings(self.defaults, {'SPOTIFY_BITRATE': 50}) self.assertEqual(result['SPOTIFY_BITRATE'], u'Unavailable Spotify bitrate. ' + u'Available bitrates are 96, 160, and 320.') def test_two_errors_are_both_reported(self): - result = validate_settings(self.defaults, + result = setting_utils.validate_settings(self.defaults, {'FOO': '', 'BAR': ''}) self.assertEqual(len(result), 2) def test_masks_value_if_secret(self): - secret = mask_value_if_secret('SPOTIFY_PASSWORD', 'bar') + secret = setting_utils.mask_value_if_secret('SPOTIFY_PASSWORD', 'bar') self.assertEqual(u'********', secret) def test_does_not_mask_value_if_not_secret(self): - not_secret = mask_value_if_secret('SPOTIFY_USERNAME', 'foo') + not_secret = setting_utils.mask_value_if_secret('SPOTIFY_USERNAME', 'foo') self.assertEqual('foo', not_secret) def test_does_not_mask_value_if_none(self): - not_secret = mask_value_if_secret('SPOTIFY_USERNAME', None) + not_secret = setting_utils.mask_value_if_secret('SPOTIFY_USERNAME', None) self.assertEqual(None, not_secret) class SettingsProxyTest(unittest.TestCase): def setUp(self): - self.settings = SettingsProxy(default_settings_module) + self.settings = setting_utils.SettingsProxy(mopidy.settings) self.settings.local.clear() def test_set_and_get_attr(self): @@ -83,7 +82,7 @@ class SettingsProxyTest(unittest.TestCase): try: _ = self.settings.TEST self.fail(u'Should raise exception') - except SettingsError as e: + except mopidy.SettingsError as e: self.assertEqual(u'Setting "TEST" is not set.', e.message) def test_getattr_raises_error_on_empty_setting(self): @@ -91,7 +90,7 @@ class SettingsProxyTest(unittest.TestCase): try: _ = self.settings.TEST self.fail(u'Should raise exception') - except SettingsError as e: + except mopidy.SettingsError as e: self.assertEqual(u'Setting "TEST" is empty.', e.message) def test_getattr_does_not_raise_error_if_setting_is_false(self): @@ -177,44 +176,68 @@ class SettingsProxyTest(unittest.TestCase): class FormatSettingListTest(unittest.TestCase): def setUp(self): - self.settings = SettingsProxy(default_settings_module) + self.settings = setting_utils.SettingsProxy(mopidy.settings) def test_contains_the_setting_name(self): self.settings.TEST = u'test' - result = format_settings_list(self.settings) + result = setting_utils.format_settings_list(self.settings) self.assert_('TEST:' in result, result) def test_repr_of_a_string_value(self): self.settings.TEST = u'test' - result = format_settings_list(self.settings) + result = setting_utils.format_settings_list(self.settings) self.assert_("TEST: u'test'" in result, result) def test_repr_of_an_int_value(self): self.settings.TEST = 123 - result = format_settings_list(self.settings) + result = setting_utils.format_settings_list(self.settings) self.assert_("TEST: 123" in result, result) def test_repr_of_a_tuple_value(self): self.settings.TEST = (123, u'abc') - result = format_settings_list(self.settings) + result = setting_utils.format_settings_list(self.settings) self.assert_("TEST: (123, u'abc')" in result, result) def test_passwords_are_masked(self): self.settings.TEST_PASSWORD = u'secret' - result = format_settings_list(self.settings) + result = setting_utils.format_settings_list(self.settings) self.assert_("TEST_PASSWORD: u'secret'" not in result, result) self.assert_("TEST_PASSWORD: u'********'" in result, result) def test_short_values_are_not_pretty_printed(self): self.settings.FRONTEND = (u'mopidy.frontends.mpd.MpdFrontend',) - result = format_settings_list(self.settings) + result = setting_utils.format_settings_list(self.settings) self.assert_("FRONTEND: (u'mopidy.frontends.mpd.MpdFrontend',)" in result, result) def test_long_values_are_pretty_printed(self): self.settings.FRONTEND = (u'mopidy.frontends.mpd.MpdFrontend', u'mopidy.frontends.lastfm.LastfmFrontend') - result = format_settings_list(self.settings) + result = setting_utils.format_settings_list(self.settings) self.assert_("""FRONTEND: (u'mopidy.frontends.mpd.MpdFrontend', u'mopidy.frontends.lastfm.LastfmFrontend')""" in result, result) + + +class DidYouMeanTest(unittest.TestCase): + def testSuggestoins(self): + defaults = { + 'MPD_SERVER_HOSTNAME': '::', + 'MPD_SERVER_PORT': 6600, + 'SPOTIFY_BITRATE': 160, + } + + suggestion = setting_utils.did_you_mean('spotify_bitrate', defaults) + self.assertEqual(suggestion, 'SPOTIFY_BITRATE') + + suggestion = setting_utils.did_you_mean('SPOTIFY_BITROTE', defaults) + self.assertEqual(suggestion, 'SPOTIFY_BITRATE') + + suggestion = setting_utils.did_you_mean('SPITIFY_BITROT', defaults) + self.assertEqual(suggestion, 'SPOTIFY_BITRATE') + + suggestion = setting_utils.did_you_mean('SPTIFY_BITROT', defaults) + self.assertEqual(suggestion, 'SPOTIFY_BITRATE') + + suggestion = setting_utils.did_you_mean('SPTIFY_BITRO', defaults) + self.assertEqual(suggestion, None)