-# python-musicpd: Python MPD client library
-# Copyright (C) 2012-2021 kaliko <kaliko@azylum.org>
-# Copyright (C) 2019 Naglis Jonaitis <naglis@mailbox.org>
-# Copyright (C) 2019 Bart Van Loon <bbb@bbbart.be>
-# Copyright (C) 2008-2010 J. Alexander Treuman <jat@spatialrift.net>
-#
-# python-musicpd is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# python-musicpd is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-# GNU Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with python-musicpd. If not, see <http://www.gnu.org/licenses/>.
-
-# pylint: disable=missing-docstring
+# SPDX-FileCopyrightText: 2012-2022 kaliko <kaliko@azylum.org>
+# SPDX-FileCopyrightText: 2021 Wonko der Verständige <wonko@hanstool.org>
+# SPDX-FileCopyrightText: 2019 Naglis Jonaitis <naglis@mailbox.org>
+# SPDX-FileCopyrightText: 2019 Bart Van Loon <bbb@bbbart.be>
+# SPDX-FileCopyrightText: 2008-2010 J. Alexander Treuman <jat@spatialrift.net>
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""python-musicpd: Python Music Player Daemon client library"""
+
import socket
import os
ERROR_PREFIX = "ACK "
SUCCESS = "OK"
NEXT = "list_OK"
-VERSION = '0.7.0'
+VERSION = '0.9.0b0'
#: Seconds before a connection attempt times out
#: (overriden by MPD_TIMEOUT env. var.)
CONNECTION_TIMEOUT = 30
for index in self.tpl:
try:
index = int(index)
- except (TypeError, ValueError):
- raise CommandError('Not a tuple of int')
+ except (TypeError, ValueError) as err:
+ raise CommandError('Not a tuple of int') from err
class _NotConnected:
def __getattr__(self, attr):
return self._dummy
- def _dummy(*args):
+ def _dummy(self, *args):
raise ConnectionError("Not connected")
#: Socket timeout value in seconds
self._socket_timeout = SOCKET_TIMEOUT
#: Current connection timeout value, defaults to
- #: :py:attr:`musicpd.MPD_TIMEOUT` or env. var. ``MPD_TIMEOUT`` if provided
+ #: :py:obj:`CONNECTION_TIMEOUT` or env. var. ``MPD_TIMEOUT`` if provided
self.mpd_timeout = None
self._reset()
self._commands = {
if command not in self._commands:
command = command.replace("_", " ")
if command not in self._commands:
- raise AttributeError("'%s' object has no attribute '%s'" %
- (self.__class__.__name__, attr))
+ cls = self.__class__.__name__
+ raise AttributeError(f"'{cls}' object has no attribute '{attr}'")
return lambda *args: wrapper(command, args)
def _send(self, command, args):
if retval is not None:
self._pending.append(command)
- def _fetch(self, command, args=None):
+ def _fetch(self, command, args=None): # pylint: disable=unused-argument
+ cmd_fmt = command.replace(" ", "_")
if self._command_list is not None:
- raise CommandListError("Cannot use fetch_%s in a command list" %
- command.replace(" ", "_"))
+ raise CommandListError(f"Cannot use fetch_{cmd_fmt} in a command list")
if self._iterating:
- raise IteratingError("Cannot use fetch_%s while iterating" %
- command.replace(" ", "_"))
+ raise IteratingError(f"Cannot use fetch_{cmd_fmt} while iterating")
if not self._pending:
raise PendingCommandError("No pending commands to fetch")
if self._pending[0] != command:
- raise PendingCommandError("'%s' is not the currently "
- "pending command" % command)
+ raise PendingCommandError(f"'{command}' is not the currently pending command")
del self._pending[0]
retval = self._commands[command]
if callable(retval):
return retval()
return retval
- def _execute(self, command, args):
+ def _execute(self, command, args): # pylint: disable=unused-argument
if self._iterating:
- raise IteratingError("Cannot execute '%s' while iterating" %
- command)
+ raise IteratingError(f"Cannot execute '{command}' while iterating")
if self._pending:
- raise PendingCommandError(
- "Cannot execute '%s' with pending commands" % command)
+ raise PendingCommandError(f"Cannot execute '{command}' with pending commands")
retval = self._commands[command]
if self._command_list is not None:
if not callable(retval):
- raise CommandListError(
- "'%s' not allowed in command list" % command)
+ raise CommandListError(f"'{command}' not allowed in command list")
self._write_command(command, args)
self._command_list.append(retval)
else:
if callable(retval):
return retval()
return retval
+ return None
def _write_line(self, line):
- self._wfile.write("%s\n" % line)
+ self._wfile.write(f"{line!s}\n")
self._wfile.flush()
def _write_command(self, command, args=None):
raise CommandError(error)
if self._command_list is not None:
if line == NEXT:
- return
+ return None
if line == SUCCESS:
- raise ProtocolError("Got unexpected '%s'" % SUCCESS)
+ raise ProtocolError(f"Got unexpected '{SUCCESS}'")
elif line == SUCCESS:
- return
+ return None
return line
def _read_pair(self, separator, binary=False):
line = self._read_line(binary=binary)
if line is None:
- return
+ return None
pair = line.split(separator, 1)
if len(pair) < 2:
- raise ProtocolError("Could not parse pair: '%s'" % line)
+ raise ProtocolError(f"Could not parse pair: '{line}'")
return pair
def _read_pairs(self, separator=": ", binary=False):
for key, value in self._read_pairs():
if key != seen:
if seen is not None:
- raise ProtocolError("Expected key '%s', got '%s'" %
- (seen, key))
+ raise ProtocolError(f"Expected key '{seen}', got '{key}'")
seen = key
yield value
def _fetch_nothing(self):
line = self._read_line()
if line is not None:
- raise ProtocolError("Got unexpected return value: '%s'" % line)
+ raise ProtocolError(f"Got unexpected return value: '{line}'")
def _fetch_item(self):
pairs = list(self._read_pairs())
if len(pairs) != 1:
- return
+ return None
return pairs[0][1]
@iterator_wrapper
try:
obj['data'] = self._read_binary(amount)
except IOError as err:
- raise ConnectionError('Error reading binary content: %s' % err)
- if len(obj['data']) != amount: # can we ever get there?
+ raise ConnectionError(f'Error reading binary content: {err}') from err
+ data_bytes = len(obj['data'])
+ if data_bytes != amount: # can we ever get there?
raise ConnectionError('Error reading binary content: '
- 'Expects %sB, got %s' % (amount, len(obj['data'])))
+ f'Expects {amount}B, got {data_bytes}')
# Fetches trailing new line
self._read_line(binary=True)
# Fetches SUCCESS code
raise ConnectionError("Connection lost while reading MPD hello")
line = line.rstrip("\n")
if not line.startswith(HELLO_PREFIX):
- raise ProtocolError("Got invalid MPD hello: '%s'" % line)
+ raise ProtocolError(f"Got invalid MPD hello: '{line}'")
self.mpd_version = line[len(HELLO_PREFIX):].strip()
def _reset(self):
def _connect_unix(self, path):
if not hasattr(socket, "AF_UNIX"):
- raise ConnectionError(
- "Unix domain sockets not supported on this platform")
+ raise ConnectionError("Unix domain sockets not supported on this platform")
# abstract socket
if path.startswith('@'):
path = '\0'+path[1:]
sock.close()
if err is not None:
raise ConnectionError(str(err))
- else:
- raise ConnectionError("getaddrinfo returns an empty list")
+ raise ConnectionError("getaddrinfo returns an empty list")
def noidle(self):
# noidle's special case
if not self._pending or self._pending[0] != 'idle':
- raise CommandError(
- 'cannot send noidle if send_idle was not called')
+ raise CommandError('cannot send noidle if send_idle was not called')
del self._pending[0]
self._write_command("noidle")
return self._fetch_list()
self._sock.close()
self._reset()
+ def __enter__(self):
+ self.connect()
+ return self
+
+ def __exit__(self, exception_type, exception_value, exception_traceback):
+ self.disconnect()
+
def fileno(self):
"""Return the socket’s file descriptor (a small integer).
This is useful with :py:obj:`select.select`.
if self._iterating:
raise IteratingError("Cannot begin command list while iterating")
if self._pending:
- raise PendingCommandError("Cannot begin command list "
- "with pending commands")
+ raise PendingCommandError("Cannot begin command list with pending commands")
self._write_command("command_list_ok_begin")
self._command_list = []
home / dev / repositories / python-musicpd.git / blobdiff