… code

…y=?)

xl.unicode.strxfrm has been removed because it's not needed anymore.

In python2, the alldatadir received via command-line was a byte
string, and thus we did a sequence of decode() and encode() to
remove any non-ASCII characters. This was necessary because if
there were UTF-8 characters in the string, the os.path.join()
call threw exception.

In python3, the alldatadir is a unicode string, so we need to
change the sequence to encode(), followed by decode(). It is also
worth noting that os.path.join() does not take issues with UTF-8
characters anymore, so perhaps the whole code block can be removed.

But for now, we replace the non-ASCII characters to ? to keep the
behavior consistent with the old version...

Python3 file object returns unicode str objects, so GioFileInputStream
needs to mimic that behavior...

…) str

Use urllib.parse instead of urllib2.
Use 'unicode' when converting ETree to string in order to obtain
a python3 str object.

Because response.read() returns a byte string.

In both plugins, removed encode('utf-8') calls on artist
and title tag, which converted str to bytes and in turn caused errors
with replace() calls.

Similarly in lyricwiki plugin, the web page content, obtained via
renderContents(), needs to be converted from bytes to str before
subsequent replace() and split() calls.

We were comparing int(m.props.position * track_length) against
playback_time, but because the latter was a float, the comparison
was never true. So convert the playback_time to int before the
comparison to catch the moment when marker is reached.

Should fix the segment repeating in A-B repeat plugin.

The str (unicode) value needs to be encoded to bytes before
passed to the hash function.

Passing multiple tags via kwargs is not supported by set_tag_raw,
resulting in error.

In this plugin, the open() call in save function needs to be done
in non-binary mode, because otherwise json.dump() function throws
an error about trying to write an str instead of bytes.

The load function seems to work with both binary and
non-binary open(), so use non-binary to be consistent.

When merging list of byte-strings, the delimiter string needs to
be a byte-string as well.

Because we are directly reading/write json, which is a str and
not bytes.

In that case, the player.QUEUE.set_current_playlist() needs to
be passed the playlist, not a playlist page.

…on()

Provide default values for the options retrieved from settings.
This is necessary because otherwise we get a None for option that
has not been explicitly modified via UI. The defaults are set
to the values that are displayed by UI.

Fixes the fade-in functionality.

Because the rest of the processing seems to expect str objects,
not bytes.

…ed_tags

In python3, greater-than and less-than comparison between a None
and a string is invalid. Therefore, the tag_data_key() not
returning a value for None-valued td causes errors.

So it seems a better idea to just discard the None elements at
the very beginning.

The template needs to be read in non-binary mode. The output
contents need to be encoded to bytes because that is what
Gio.FileOutputStream.write() is expecting. The d3 file needs to
be read in binary mode, because the resulting bytes are directly
passed to a Gio.FileOutputStream.write().

In joiner(), we really need to distinguish only between lists
(which need to be joined) and other (which are returned as-is).

So rework the logic to use isinstance(value, list) instead of
isinstance(value, basestring). Also, always join using the
str-based separator, as tags should always be str objects now.

The text returned by buffer.get_text() is already a str instance,
so trying to convert it to str again with specified encoding
results in error.

Use replace('\n', '\\n') and replace('\\n', '\n') to escape
newlines instead of encode()/decode() with 'unicode_escape',
which also involve conversion from and to bytes.

All marked divisions should be float divisions.

Changed sheband from python2 to python3 in several tools and in
plugin files that have defined main.

Removed the shebang from plugin files that do not have main
defined.

…ted issues

This goes for the base64-encoded covert image daa as well. Fixes
the remaining test error.

These mainly involve missing gi.require_version() before imports,
and use of deprecated GObject.PARAM_READWRITE instead of
GObject.ParamFlags.READWRITE.

The remaining warnings from the test suite (about deprecation of
inspect.getargspec() since Python 3.0) come from mox and are
beyond out control.

Signals prefetch-started, prefetch-progress, prefetch-completed,
fetch-started, fetch-progress, fetch-completed, and cover-fetched
are emitted from a worker thread. Because their do_() callbacks
peforms GUI operations, they need to be executed within the
main thread, which is achieved by adding the @common.idle_add()
decorator.

Fixes a crash when opening cover manager (Edit->Covers), and
clicking on Fetch Covers.

Use ctx.call_on_close() to register a callback that explicitly
closes the opened shelf. This way, we ensure that the shelf is
closed before the underyling database and avoid the message
"bsddb3.db.DBError: BSDDB object has already been closed" when
the program ends.

Needed for compatibility with python2-created music db.

This code is duplicated in tools/db_explorer.py so it doesn't have to
depend on xl.

Use the python3 syntax for metaclass instead of compatibility
with_metaclass() function.

This simplifies the code a bit, removing the update_playlist_node function
and rolling it into the only place that needs it. Also removes a bit of
unnecessary code in _drag_data_received_uris.

The old python2 (byte) str -> unicode conversion has been replaced
with str() conversion by futurize. These are redundant, because
under python3, these strings are already str instances. (Except
for the TDRC/TDOR, which are ID3TimeStamps and still need to be
converted to str).

Added comments about the use of explicit str() conversion in places
where this is (or may be necessary).

While the sort tag value is usually a string, it is not always so;
for example, in case of track number tag.

The first_meaningful_char() is in practice always called with a
str argument due to the way our sort filters are currently
constructed. But keep the str() conversion there as well, in case
the sort groups get changed in the future.

Removed an invalid str decode attempt in _expand_node_by_name(),
which is a left-over from python2 codebase. I suspect that this
method is actually not used anywhere, otherwise the decode attempt
would have triggered an error.

A left-over from python2 where the check was done against str and
unicode. But now, we need to check only for str, because sort level
entry is either a str or a tuple.

The get_selected_tracks() was constructing list of track groups
(lists/tuples), merging them into a single list via reduce(),
then filtering out duplicates via set(), and finally converting
the set back to list.

This is now simplified by constructing the set on-the-fly, and
then converting it to the list.