Make all Python files PEP8 compatible.

Thu, 01 Sep 2016 23:58:47 -0400

author
Elliott Sales de Andrade <qulogic@pidgin.im>
date
Thu, 01 Sep 2016 23:58:47 -0400
changeset 37984
6a5ca046a90d
parent 37983
7d134a4a87b2
child 37985
c3bab3be9695

Make all Python files PEP8 compatible.

finch/plugins/pietray.py file | annotate | diff | comparison | revisions
libpurple/dbus-analyze-functions.py file | annotate | diff | comparison | revisions
libpurple/dbus-analyze-signals.py file | annotate | diff | comparison | revisions
libpurple/dbus-analyze-types.py file | annotate | diff | comparison | revisions
libpurple/plugins/dbus-buddyicons-example.py file | annotate | diff | comparison | revisions
libpurple/plugins/startup.py file | annotate | diff | comparison | revisions
libpurple/purple-notifications-example file | annotate | diff | comparison | revisions
libpurple/purple-remote file | annotate | diff | comparison | revisions
libpurple/purple-url-handler file | annotate | diff | comparison | revisions
--- a/finch/plugins/pietray.py	Thu Sep 01 23:42:21 2016 -0400
+++ b/finch/plugins/pietray.py	Thu Sep 01 23:58:47 2016 -0400
@@ -12,198 +12,224 @@
 #      the tooltip.
 #    - It can blink on unread IM/Chat messages, and it allows canging
 #      the preference for that.
-# 
+#
 # It requires GTK+ 2.10 or above, since it uses GtkStatusIcon.
-# 
+#
 # Sadrul <sadrul@pidgin.im>
 
 from __future__ import absolute_import, division, print_function
 
+import os  # to get the pkg-config output
+
 import pygtk
 pygtk.require("2.0")
 import gtk
-import dbus, gobject, dbus.glib
-import os # to get the pkg-config output
+import dbus
+import dbus.glib
+
 
 bus = dbus.SessionBus()
-obj = bus.get_object(
-    "im.pidgin.purple.PurpleService", "/im/pidgin/purple/PurpleObject")
+obj = bus.get_object("im.pidgin.purple.PurpleService",
+                     "/im/pidgin/purple/PurpleObject")
 purple = dbus.Interface(obj, "im.pidgin.purple.PurpleInterface")
 
+
 def pack_image_label(menu, image, label):
-	item = gtk.ImageMenuItem(label)
-	if image:
-		img = gtk.Image()
-		img.set_from_stock(image, 1)
-		item.set_image(img)
-	menu.append(item)
-	return item
+    item = gtk.ImageMenuItem(label)
+    if image:
+        img = gtk.Image()
+        img.set_from_stock(image, 1)
+        item.set_image(img)
+    menu.append(item)
+    return item
+
 
 def activate_primitive_status(item, status):
-	saved = purple.PurpleSavedstatusFindTransientByTypeAndMessage(status, "")
-	if not saved:
-		saved = purple.PurpleSavedstatusNew("", status)
-	purple.PurpleSavedstatusActivate(saved)
+    saved = purple.PurpleSavedstatusFindTransientByTypeAndMessage(status, "")
+    if not saved:
+        saved = purple.PurpleSavedstatusNew("", status)
+    purple.PurpleSavedstatusActivate(saved)
+
 
 def activate_popular_status(item, time):
-	saved = purple.PurpleSavedstatusFindByCreationTime(time)
-	if saved:
-		purple.PurpleSavedstatusActivate(saved)
+    saved = purple.PurpleSavedstatusFindByCreationTime(time)
+    if saved:
+        purple.PurpleSavedstatusActivate(saved)
+
 
 def generate_status_menu(menu):
-	item = gtk.MenuItem("Available")
-	item.connect("activate", activate_primitive_status, 2)
-	menu.append(item)
+    item = gtk.MenuItem("Available")
+    item.connect("activate", activate_primitive_status, 2)
+    menu.append(item)
 
-	item = gtk.MenuItem("Away")
-	item.connect("activate", activate_primitive_status, 5)
-	menu.append(item)
+    item = gtk.MenuItem("Away")
+    item.connect("activate", activate_primitive_status, 5)
+    menu.append(item)
 
-	item = gtk.MenuItem("Invisible")
-	item.connect("activate", activate_primitive_status, 4)
-	menu.append(item)
+    item = gtk.MenuItem("Invisible")
+    item.connect("activate", activate_primitive_status, 4)
+    menu.append(item)
 
-	item = gtk.MenuItem("Offline")
-	item.connect("activate", activate_primitive_status, 1)
-	menu.append(item)
+    item = gtk.MenuItem("Offline")
+    item.connect("activate", activate_primitive_status, 1)
+    menu.append(item)
 
-	menu.append(gtk.MenuItem())
+    menu.append(gtk.MenuItem())
 
-	popular = purple.PurpleSavedstatusesGetPopular(10)
-	for pop in popular:
-		title = purple.PurpleSavedstatusGetTitle(pop).replace('_', '__')
-		item = gtk.MenuItem(title)
-		item.set_data("timestamp", purple.PurpleSavedstatusGetCreationTime(pop))
-		item.connect("activate", activate_popular_status, purple.PurpleSavedstatusGetCreationTime(pop))
-		menu.append(item)
+    popular = purple.PurpleSavedstatusesGetPopular(10)
+    for pop in popular:
+        title = purple.PurpleSavedstatusGetTitle(pop).replace('_', '__')
+        item = gtk.MenuItem(title)
+        item.set_data("timestamp",
+                      purple.PurpleSavedstatusGetCreationTime(pop))
+        item.connect("activate", activate_popular_status,
+                     purple.PurpleSavedstatusGetCreationTime(pop))
+        menu.append(item)
+
 
 def toggle_pref(item, pref):
-	purple.PurplePrefsSetBool(pref, item.get_active())
+    purple.PurplePrefsSetBool(pref, item.get_active())
+
 
 def quit_finch(item, null):
-	# XXX: Ask first
-	purple.PurpleCoreQuit()
-	gtk.main_quit()
+    # XXX: Ask first
+    purple.PurpleCoreQuit()
+    gtk.main_quit()
+
 
 def close_docklet(item, null):
-	gtk.main_quit()
+    gtk.main_quit()
+
 
 def popup_menu(icon, button, tm, none):
-	menu = gtk.Menu()
+    menu = gtk.Menu()
 
-	#item = gtk.ImageMenuItem(gtk.STOCK_QUIT)
-	#item.connect("activate", quit_finch, None)
-	#menu.append(item)
+    # item = gtk.ImageMenuItem(gtk.STOCK_QUIT)
+    # item.connect("activate", quit_finch, None)
+    # menu.append(item)
 
-	item = gtk.ImageMenuItem(gtk.STOCK_CLOSE)
-	item.connect("activate", close_docklet, None)
-	menu.append(item)
+    item = gtk.ImageMenuItem(gtk.STOCK_CLOSE)
+    item.connect("activate", close_docklet, None)
+    menu.append(item)
+
+    menu.append(gtk.MenuItem())
 
-	menu.append(gtk.MenuItem())
-
-	item = gtk.CheckMenuItem("Blink for unread IM")
-	item.set_active(purple.PurplePrefsGetBool("/plugins/dbus/docklet/blink/im"))
-	item.connect("activate", toggle_pref, "/plugins/dbus/docklet/blink/im")
-	menu.append(item)
+    item = gtk.CheckMenuItem("Blink for unread IM")
+    item.set_active(
+        purple.PurplePrefsGetBool("/plugins/dbus/docklet/blink/im"))
+    item.connect("activate", toggle_pref, "/plugins/dbus/docklet/blink/im")
+    menu.append(item)
 
-	item = gtk.CheckMenuItem("Blink for unread Chats")
-	item.set_active(purple.PurplePrefsGetBool("/plugins/dbus/docklet/blink/chat"))
-	item.connect("activate", toggle_pref, "/plugins/dbus/docklet/blink/chat")
-	menu.append(item)
+    item = gtk.CheckMenuItem("Blink for unread Chats")
+    item.set_active(
+        purple.PurplePrefsGetBool("/plugins/dbus/docklet/blink/chat"))
+    item.connect("activate", toggle_pref, "/plugins/dbus/docklet/blink/chat")
+    menu.append(item)
 
-	menu.append(gtk.MenuItem())
+    menu.append(gtk.MenuItem())
 
-	#item = pack_image_label(menu, None, "Change Status...")
-	item = gtk.MenuItem("Change Status...")
-	menu.append(item)
-	submenu = gtk.Menu()
-	item.set_submenu(submenu)
-	generate_status_menu(submenu)
+    # item = pack_image_label(menu, None, "Change Status...")
+    item = gtk.MenuItem("Change Status...")
+    menu.append(item)
+    submenu = gtk.Menu()
+    item.set_submenu(submenu)
+    generate_status_menu(submenu)
 
-	menu.show_all()
-	menu.popup(None, None, None, button, tm)
+    menu.show_all()
+    menu.popup(None, None, None, button, tm)
+
 
 def get_status_message():
-	status = purple.PurpleSavedstatusGetCurrent()
-	msg = purple.PurpleSavedstatusGetMessage(status)
-	if msg and len(msg) > 0:
-		text = msg + " "
-	else:
-		text = ""
-	text = text + "(" + {
-		2: "Available",
-		5: "Away",
-		4: "Invisible",
-		1: "Offline"
-	}[purple.PurpleSavedstatusGetType(status)] + ")"
-	return text
+    status = purple.PurpleSavedstatusGetCurrent()
+    msg = purple.PurpleSavedstatusGetMessage(status)
+    if msg and len(msg) > 0:
+        text = msg + " "
+    else:
+        text = ""
+    text = text + "(" + {
+        2: "Available",
+        5: "Away",
+        4: "Invisible",
+        1: "Offline"
+    }[purple.PurpleSavedstatusGetType(status)] + ")"
+    return text
+
 
 def detect_unread_conversations():
-	im = purple.PurplePrefsGetBool("/plugins/dbus/docklet/blink/im")
-	chat = purple.PurplePrefsGetBool("/plugins/dbus/docklet/blink/chat")
-	tooltip = ""
-	blink = False
-	if im and chat:
-		convs = purple.PurpleGetConversations()
-	elif im:
-		convs = purple.PurpleGetIms()
-	elif chat:
-		convs = purple.PurpleGetChats()
-	else:
-		convs = None
-	for conv in convs:
-		count = purple.PurpleConversationGetData(conv, "unseen-count")
-		if count and count > 0:
-			blink = True
-			tooltip = tooltip + "\n" + purple.PurpleConversationGetName(conv) + " (" + str(count) + ")"
-	t.set_from_file(path + "/share/pixmaps/pidgin.png")
-	if blink:
-		# I hate this icon
-		# t.set_from_file(path + "/share/pixmaps/pidgin/tray/22/tray-message.png")
-		tooltip = "\nUnread Messages:" + tooltip
-	# There's going to be some way to expose the client's display name in 2.1.0.
-	# Use that instead of hardcoding Finch here.
-	t.set_tooltip("Finch: " + get_status_message() + tooltip)
-	t.set_blinking(blink)
+    im = purple.PurplePrefsGetBool("/plugins/dbus/docklet/blink/im")
+    chat = purple.PurplePrefsGetBool("/plugins/dbus/docklet/blink/chat")
+    tooltip = ""
+    blink = False
+    if im and chat:
+        convs = purple.PurpleGetConversations()
+    elif im:
+        convs = purple.PurpleGetIms()
+    elif chat:
+        convs = purple.PurpleGetChats()
+    else:
+        convs = None
+    for conv in convs:
+        count = purple.PurpleConversationGetData(conv, "unseen-count")
+        if count and count > 0:
+            blink = True
+            tooltip += "\n%s (%d)" % (purple.PurpleConversationGetName(conv),
+                                      count)
+    t.set_from_file(path + "/share/pixmaps/pidgin.png")
+    if blink:
+        # I hate this icon
+        # t.set_from_file(path +
+        #                 "/share/pixmaps/pidgin/tray/22/tray-message.png")
+        tooltip = "\nUnread Messages:" + tooltip
+    # There's going to be some way to expose the client's display name in
+    # 2.1.0. Use that instead of hardcoding Finch here.
+    t.set_tooltip("Finch: " + get_status_message() + tooltip)
+    t.set_blinking(blink)
+
 
 def conversation_updated(conv, type):
-	detect_unread_conversations()
+    detect_unread_conversations()
+
 
 def savedstatus_changed(new, old):
-	# Change the icon for status perhaps?
-	detect_unread_conversations()
+    # Change the icon for status perhaps?
+    detect_unread_conversations()
+
 
 def init_prefs():
-	if not purple.PurplePrefsExists("/plugins/dbus/docklet/blink"):
-		purple.PurplePrefsAddNone("/plugins")
-		purple.PurplePrefsAddNone("/plugins/dbus")
-		purple.PurplePrefsAddNone("/plugins/dbus/docklet")
-		purple.PurplePrefsAddNone("/plugins/dbus/docklet/blink")
-		purple.PurplePrefsAddBool("/plugins/dbus/docklet/blink/im", True)
-		purple.PurplePrefsAddBool("/plugins/dbus/docklet/blink/chat", True)
+    if not purple.PurplePrefsExists("/plugins/dbus/docklet/blink"):
+        purple.PurplePrefsAddNone("/plugins")
+        purple.PurplePrefsAddNone("/plugins/dbus")
+        purple.PurplePrefsAddNone("/plugins/dbus/docklet")
+        purple.PurplePrefsAddNone("/plugins/dbus/docklet/blink")
+        purple.PurplePrefsAddBool("/plugins/dbus/docklet/blink/im", True)
+        purple.PurplePrefsAddBool("/plugins/dbus/docklet/blink/chat", True)
+
 
 pkg = os.popen("pkg-config --variable=prefix pidgin")
 path = pkg.readline().rstrip()
 
 bus.add_signal_receiver(conversation_updated,
-  dbus_interface="im.pidgin.purple.PurpleInterface",
-  signal_name="ConversationUpdated")
+                        dbus_interface="im.pidgin.purple.PurpleInterface",
+                        signal_name="ConversationUpdated")
 
 bus.add_signal_receiver(savedstatus_changed,
-  dbus_interface="im.pidgin.purple.PurpleInterface",
-  signal_name="SavedstatusChanged")
+                        dbus_interface="im.pidgin.purple.PurpleInterface",
+                        signal_name="SavedstatusChanged")
 
 t = gtk.StatusIcon()
 t.connect("popup-menu", popup_menu, None)
 
 try:
-	init_prefs()
-	detect_unread_conversations()
-	gtk.main ()
+    init_prefs()
+    detect_unread_conversations()
+    gtk.main()
 except:
-	dialog = gtk.Dialog("pietray: Error", None, gtk.DIALOG_NO_SEPARATOR | gtk.DIALOG_MODAL, ("Close", gtk.RESPONSE_CLOSE))
-	dialog.set_resizable(False)
-	dialog.vbox.pack_start(gtk.Label("There was some error. Perhaps a purple client is not running."), False, False, 0)
-	dialog.show_all()
-	dialog.run()
-
+    dialog = gtk.Dialog("pietray: Error", None,
+                        gtk.DIALOG_NO_SEPARATOR | gtk.DIALOG_MODAL,
+                        ("Close", gtk.RESPONSE_CLOSE))
+    dialog.set_resizable(False)
+    error_label = gtk.Label("There was some error. Perhaps a purple client is "
+                            "not running.")
+    dialog.vbox.pack_start(error_label, False, False, 0)
+    dialog.show_all()
+    dialog.run()
--- a/libpurple/dbus-analyze-functions.py	Thu Sep 01 23:42:21 2016 -0400
+++ b/libpurple/dbus-analyze-functions.py	Thu Sep 01 23:58:47 2016 -0400
@@ -3,18 +3,19 @@
 import argparse
 import fileinput
 import re
-import string
 import sys
 
+
 # types translated into "int"
-simpletypes = ["int", "gint", "guint", "gboolean", "size_t", "gssize", "time_t"]
+simpletypes = ["int", "gint", "guint", "gboolean", "size_t", "gssize",
+               "time_t"]
 
 # List "excluded" contains functions that shouldn't be exported via
 # DBus.  If you remove a function from this list, please make sure
 # that it does not break "make" with the configure option
 # "--enable-dbus" turned on.
 
-excluded = [\
+excluded = [
     # I don't remember why this function is excluded; something to do
     # with the fact that it takes a (const) GList as a parameter.
     "purple_presence_add_list",
@@ -58,7 +59,7 @@
 
     # Similiar to the above:
     "purple_notify_is_valid_ui_handle",
-    ]
+]
 
 # This is a list of functions that return a GList* or GSList * whose elements
 # are strings, not pointers to objects.
@@ -99,35 +100,40 @@
 
 pointer = "#pointer#"
 
+
 class MyException(Exception):
     pass
 
+
 myexception = MyException()
 
+
 def ctopascal(name):
     newname = ""
     for word in name.split("_"):
         newname += word.capitalize()
     return newname
 
+
 class Parameter(object):
     def __init__(self, type, name):
         self.name = name
         self.type = type
 
-    def fromtokens(tokens, parameternumber = -1):
+    def fromtokens(tokens, parameternumber=-1):
         if len(tokens) == 0:
             raise myexception
-        if (len(tokens) == 1) or (tokens[-1] == pointer):
+        if len(tokens) == 1 or tokens[-1] == pointer:
             if parameternumber >= 0:
-                return Parameter(tokens, "param%i" % parameternumber)
+                return Parameter(tokens, "param%i" % (parameternumber, ))
             else:
                 raise myexception
         else:
             return Parameter(tokens[:-1], tokens[-1])
-                    
+
     fromtokens = staticmethod(fromtokens)
 
+
 class Binding(object):
     def __init__(self, functiontext, paramtexts, output=None):
         self.function = Parameter.fromtokens(functiontext.split())
@@ -164,11 +170,13 @@
 
         if len(type) == 1:
             # simple types (int, gboolean, etc.) and enums
-            if (type[0] in simpletypes) or ((type[0].startswith("Purple") and not type[0].endswith("Callback"))):
+            if type[0] in simpletypes or (
+                    type[0].startswith("Purple") and
+                    not type[0].endswith("Callback")):
                 return self.inputsimple(type, name, unsigned)
 
-        # pointers ... 
-        if (len(type) == 2) and (type[1] == pointer):
+        # pointers ...
+        if len(type) == 2 and type[1] == pointer:
             # strings
             if type[0] in ["char", "gchar"]:
                 if const:
@@ -178,7 +186,7 @@
 
             elif type[0] == "GHashTable":
                 return self.inputhash(type, name)
-                
+
             # known object types are transformed to integer handles
             elif type[0].startswith("Purple"):
                 return self.inputpurplestructure(type, name)
@@ -186,14 +194,13 @@
             # special case for *_get_data functions, be careful here...
             elif (type[0] == "size_t" or type[0] == "gsize") and name == "len":
                 return self.inputgetdata(type, name)
-            
+
             # unknown pointers are always replaced with NULL
             else:
                 return self.inputpointer(type, name)
 
         raise myexception
 
-   
     def processoutput(self, type, name):
         const = False
         unsigned = False
@@ -214,13 +221,12 @@
             return self.outputstring(type, name, const)
 
         # simple types (ints, booleans, enums, ...)
-        if (len(type) == 1) and \
-               ((type[0] in simpletypes) or (type[0].startswith("Purple"))):
+        if (len(type) == 1 and
+               (type[0] in simpletypes or type[0].startswith("Purple"))):
             return self.outputsimple(type, name, unsigned)
 
         # pointers ...
-        if (len(type) == 2) and (type[1] == pointer):
-
+        if len(type) == 2 and type[1] == pointer:
             # handles
             if type[0].startswith("Purple"):
                 return self.outputpurplestructure(type, name)
@@ -233,9 +239,9 @@
             return self.outputgetdata(type, name)
 
         raise myexception
-    
+
 
-class ClientBinding (Binding):
+class ClientBinding(Binding):
     def __init__(self, functiontext, paramtexts, knowntypes, headersonly,
                  **kwargs):
         Binding.__init__(self, functiontext, paramtexts, **kwargs)
@@ -249,7 +255,7 @@
 
     def flush(self):
         paramslist = ", ".join(self.paramshdr)
-        if (paramslist == "") :
+        if paramslist == "":
             paramslist = "void"
         print("%s %s(%s)" % (self.functiontype, self.function.name,
                              paramslist),
@@ -268,23 +274,23 @@
         print('dbus_g_proxy_call(purple_proxy, "%s", NULL,' % (
                 ctopascal(self.function.name), ),
               file=self.output)
-        
+
         for type_name in self.inputparams:
-            print("\t%s, %s, " % type_name, end=' ', file=self.output)
+            print("\t%s, %s, " % (type_name, ), end=' ', file=self.output)
         print("G_TYPE_INVALID,", file=self.output)
 
         for type_name in self.outputparams:
-            print("\t%s, &%s, " % type_name, end=' ', file=self.output)
+            print("\t%s, &%s, " % (type_name, ), end=' ', file=self.output)
         print("G_TYPE_INVALID);", file=self.output)
-        
+
         for code in self.returncode:
             print(code, file=self.output)
 
         print("}\n", file=self.output)
 
     def definepurplestructure(self, type):
-        if (self.headersonly) and (type[0] not in self.knowntypes):
-            print("struct _%s;" % type[0], file=self.output)
+        if self.headersonly and type[0] not in self.knowntypes:
+            print("struct _%s;" % (type[0], ), file=self.output)
             print("typedef struct _%s %s;" % (type[0], type[0]),
                   file=self.output)
             self.knowntypes.append(type[0])
@@ -298,34 +304,37 @@
 
     def inputstring(self, type, name, us):
         if us:
-            self.paramshdr.append("const unsigned char *%s" % name)
+            self.paramshdr.append("const unsigned char *%s" % (name, ))
         else:
-            self.paramshdr.append("const char *%s" % name)
+            self.paramshdr.append("const char *%s" % (name, ))
         self.inputparams.append(("G_TYPE_STRING", name))
-        
+
     def inputpurplestructure(self, type, name):
         self.paramshdr.append("const %s *%s" % (type[0], name))
-        self.inputparams.append(("G_TYPE_INT", "GPOINTER_TO_INT(%s)" % name))
+        self.inputparams.append(("G_TYPE_INT",
+                                 "GPOINTER_TO_INT(%s)" % (name, )))
         self.definepurplestructure(type)
 
     def inputpointer(self, type, name):
         name += "_NULL"
         self.paramshdr.append("const %s *%s" % (type[0], name))
         self.inputparams.append(("G_TYPE_INT", "0"))
-        
+
     def inputhash(self, type, name):
-        self.paramshdr.append("const GHashTable *%s" % name)
-        self.inputparams.append(('dbus_g_type_get_map ("GHashTable", G_TYPE_STRING, G_TYPE_STRING)', name))
+        self.paramshdr.append("const GHashTable *%s" % (name, ))
+        self.inputparams.append(
+            ('dbus_g_type_get_map("GHashTable", G_TYPE_STRING, G_TYPE_STRING)',
+             name))
 
     def outputvoid(self, type, name):
         self.functiontype = "void"
 
     def outputstring(self, type, name, const):
         self.functiontype = "char*"
-        self.decls.append("char *%s = NULL;" % name)
+        self.decls.append("char *%s = NULL;" % (name, ))
         self.outputparams.append(("G_TYPE_STRING", name))
-#        self.returncode.append("NULLIFY(%s);" % name)
-        self.returncode.append("return %s;" % name);
+#        self.returncode.append("NULLIFY(%s);" % (name, ))
+        self.returncode.append("return %s;" % (name, ))
 
     def outputsimple(self, type, name, us):
         self.functiontype = type[0]
@@ -334,58 +343,62 @@
             self.outputparams.append(("G_TYPE_UINT", name))
         else:
             self.outputparams.append(("G_TYPE_INT", name))
-        self.returncode.append("return %s;" % name);
+        self.returncode.append("return %s;" % (name, ))
 
     # we could add "const" to the return type but this would probably
     # be a nuisance
     def outputpurplestructure(self, type, name):
         name = name + "_ID"
-        self.functiontype = "%s*" % type[0]
-        self.decls.append("int %s = 0;" % name)
-        self.outputparams.append(("G_TYPE_INT", "%s" % name))
-        self.returncode.append("return (%s*) GINT_TO_POINTER(%s);" % (type[0], name));
+        self.functiontype = "%s*" % (type[0], )
+        self.decls.append("int %s = 0;" % (name, ))
+        self.outputparams.append(("G_TYPE_INT", "%s" % (name, )))
+        self.returncode.append("return (%s*) GINT_TO_POINTER(%s);" % (type[0],
+                                                                      name))
         self.definepurplestructure(type)
 
     def outputlist(self, type, name):
-        self.functiontype = "%s*" % type[0]
-        self.decls.append("GArray *%s;" % name)
-        self.outputparams.append(('dbus_g_type_get_collection("GArray", G_TYPE_INT)', name))
+        self.functiontype = "%s*" % (type[0], )
+        self.decls.append("GArray *%s;" % (name, ))
+        self.outputparams.append(
+            ('dbus_g_type_get_collection("GArray", G_TYPE_INT)', name))
         self.returncode.append("return garray_int_to_%s(%s);" %
-                               (type[0].lower(), name));
+                               (type[0].lower(), name))
 
     # Special case for *_get_data functions, don't need client bindings,
     #  but do need the name so it doesn't crash
     def inputgetdata(self, type, name):
         raise myexception
+
     def outputgetdata(self, type, name):
         raise myexception
 
-class ServerBinding (Binding):
+
+class ServerBinding(Binding):
     def __init__(self, functiontext, paramtexts, **kwargs):
         Binding.__init__(self, functiontext, paramtexts, **kwargs)
         self.dparams = ""
         self.cparams = []
-        self.cdecls  = []
-        self.ccode  = []
+        self.cdecls = []
+        self.ccode = []
         self.cparamsout = []
         self.ccodeout = []
         self.argfunc = "dbus_message_get_args"
 
     def flush(self):
         print("static DBusMessage*", file=self.output)
-        print("%s_DBUS(DBusMessage *message_DBUS, DBusError *error_DBUS) {" % \
+        print("%s_DBUS(DBusMessage *message_DBUS, DBusError *error_DBUS) {" %
               self.function.name,
               file=self.output)
-        
+
         print("\tDBusMessage *reply_DBUS;", file=self.output)
 
         for decl in self.cdecls:
             print(decl, file=self.output)
 
-        print("\t%s(message_DBUS, error_DBUS," % self.argfunc, end=' ',
+        print("\t%s(message_DBUS, error_DBUS," % (self.argfunc, ), end=' ',
               file=self.output)
         for param in self.cparams:
-            print("DBUS_TYPE_%s, &%s," % param, end=' ', file=self.output)
+            print("DBUS_TYPE_%s, &%s," % (param, ), end=' ', file=self.output)
         print("DBUS_TYPE_INVALID);", file=self.output)
 
         print("\tCHECK_ERROR(error_DBUS);", file=self.output)
@@ -400,9 +413,10 @@
               file=self.output)
         for param in self.cparamsout:
             if type(param) is str:
-                print("%s," % param, end=' ', file=self.output)
+                print("%s," % (param, ), end=' ', file=self.output)
             else:
-                print("DBUS_TYPE_%s, &%s," % param, end=' ', file=self.output)
+                print("DBUS_TYPE_%s, &%s," % (param, ), end=' ',
+                      file=self.output)
         print("DBUS_TYPE_INVALID);", file=self.output)
 
         for code in self.ccodeout:
@@ -420,147 +434,167 @@
     def addouttype(self, type, name):
         self.addstring("out", type, name)
 
-
     # input parameters
 
     def inputsimple(self, type, name, us):
         if us:
-            self.cdecls.append("\tdbus_uint32_t %s;" % name)
+            self.cdecls.append("\tdbus_uint32_t %s;" % (name, ))
             self.cparams.append(("UINT32", name))
             self.addintype("u", name)
         else:
-            self.cdecls.append("\tdbus_int32_t %s;" % name)
+            self.cdecls.append("\tdbus_int32_t %s;" % (name, ))
             self.cparams.append(("INT32", name))
             self.addintype("i", name)
 
     def inputstring(self, type, name, us):
         if us:
-            self.cdecls.append("\tconst unsigned char *%s;" % name)
+            self.cdecls.append("\tconst unsigned char *%s;" % (name, ))
         else:
-            self.cdecls.append("\tconst char *%s;" % name)
+            self.cdecls.append("\tconst char *%s;" % (name, ))
         self.cparams.append(("STRING", name))
-        self.ccode.append("\t%s = (%s && %s[0]) ? %s : NULL;" % (name,name,name,name))
+        self.ccode.append(
+            "\t%s = (%s && %s[0]) ? %s : NULL;" % (name, name, name, name))
         self.addintype("s", name)
 
     def inputhash(self, type, name):
         self.argfunc = "purple_dbus_message_get_args"
-        self.cdecls.append("\tDBusMessageIter %s_ITER;" % name)
-        self.cdecls.append("\tGHashTable *%s;" % name)
-        self.cparams.append(("ARRAY", "%s_ITER" % name))
-        self.ccode.append("\t%s = purple_dbus_iter_hash_table(&%s_ITER, error_DBUS);" \
-                     % (name, name))
+        self.cdecls.append("\tDBusMessageIter %s_ITER;" % (name, ))
+        self.cdecls.append("\tGHashTable *%s;" % (name, ))
+        self.cparams.append(("ARRAY", "%s_ITER" % (name, )))
+        self.ccode.append(
+            "\t%s = purple_dbus_iter_hash_table(&%s_ITER, error_DBUS);" % (
+                name,
+                name))
         self.ccode.append("\tCHECK_ERROR(error_DBUS);")
-        self.ccodeout.append("\tg_hash_table_destroy(%s);" % name)
+        self.ccodeout.append("\tg_hash_table_destroy(%s);" % (name, ))
         self.addintype("a{ss}", name)
 
     def inputpurplestructure(self, type, name):
-        self.cdecls.append("\tdbus_int32_t %s_ID;" %  name)
+        self.cdecls.append("\tdbus_int32_t %s_ID;" % (name, ))
         self.cdecls.append("\t%s *%s;" % (type[0], name))
         self.cparams.append(("INT32", name + "_ID"))
-        self.ccode.append("\tPURPLE_DBUS_ID_TO_POINTER(%s, %s_ID, %s, error_DBUS);"  % \
-                          (name, name, type[0]))
+        self.ccode.append(
+            "\tPURPLE_DBUS_ID_TO_POINTER(%s, %s_ID, %s, error_DBUS);" % (
+                name,
+                name,
+                type[0]))
         self.addintype("i", name)
 
     def inputpointer(self, type, name):
-        self.cdecls.append("\tdbus_int32_t %s_NULL;" %  name)
-        self.cdecls .append("\t%s *%s;" % (type[0], name))
+        self.cdecls.append("\tdbus_int32_t %s_NULL;" % (name, ))
+        self.cdecls.append("\t%s *%s;" % (type[0], name))
         self.cparams.append(("INT32", name + "_NULL"))
-        self.ccode  .append("\t%s = NULL;" % name)
+        self.ccode.append("\t%s = NULL;" % (name, ))
         self.addintype("i", name)
 
     # output parameters
 
     def outputvoid(self, type, name):
-        self.ccode.append("\t%s;" % self.call) # just call the function
+        self.ccode.append("\t%s;" % (self.call, ))  # just call the function
 
     def outputstring(self, type, name, const):
         if const:
-            self.cdecls.append("\tconst char *%s;" % name)
+            self.cdecls.append("\tconst char *%s;" % (name, ))
         else:
-            self.cdecls.append("\tchar *%s;" % name)
+            self.cdecls.append("\tchar *%s;" % (name, ))
         self.ccode.append("\tif ((%s = %s) == NULL)" % (name, self.call))
-        self.ccode.append("\t\t%s = \"\";" % (name))
+        self.ccode.append("\t\t%s = \"\";" % (name, ))
         self.cparamsout.append(("STRING", name))
         self.addouttype("s", name)
         if not const:
-            self.ccodeout.append("\tg_free(%s);" % name)
+            self.ccodeout.append("\tg_free(%s);" % (name, ))
 
     def outputsimple(self, type, name, us):
         if us:
-            self.cdecls.append("\tdbus_uint32_t %s;" % name)
+            self.cdecls.append("\tdbus_uint32_t %s;" % (name, ))
             self.cparamsout.append(("UINT32", name))
             self.addouttype("u", name)
         else:
-            self.cdecls.append("\tdbus_int32_t %s;" % name)
+            self.cdecls.append("\tdbus_int32_t %s;" % (name, ))
             self.cparamsout.append(("INT32", name))
             self.addouttype("i", name)
         self.ccode.append("\t%s = %s;" % (name, self.call))
 
     def outputpurplestructure(self, type, name):
-        self.cdecls.append("\tdbus_int32_t %s;" % name)
-        self.ccode .append("\tPURPLE_DBUS_POINTER_TO_ID(%s, %s, error_DBUS);" % (name, self.call))
+        self.cdecls.append("\tdbus_int32_t %s;" % (name, ))
+        self.ccode.append(
+            "\tPURPLE_DBUS_POINTER_TO_ID(%s, %s, error_DBUS);" % (name,
+                                                                  self.call))
         self.cparamsout.append(("INT32", name))
         self.addouttype("i", name)
 
     # GList*, GSList*, assume that list is a list of objects
     # unless the function is in stringlists
     def outputlist(self, type, name):
-        self.cdecls.append("\tdbus_int32_t %s_LEN;" % name)
-        self.ccodeout.append("\tg_free(%s);" % name)
+        self.cdecls.append("\tdbus_int32_t %s_LEN;" % (name, ))
+        self.ccodeout.append("\tg_free(%s);" % (name, ))
 
-        self.cdecls.append("\t%s *list;" % type[0]);
+        self.cdecls.append("\t%s *list;" % (type[0], ))
 
         if self.function.name in stringlists:
-            self.cdecls.append("\tchar **%s;" % name)
-            self.ccode.append("\tlist = %s;" % self.call)
-            self.ccode.append("\t%s = (char **)purple_%s_to_array(list, &%s_LEN);" % \
-                         (name, type[0], name))
-            self.cparamsout.append("DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &%s, %s_LEN" \
-                          % (name, name))
-            if (not (self.function.name in constlists)):
+            self.cdecls.append("\tchar **%s;" % (name, ))
+            self.ccode.append("\tlist = %s;" % (self.call, ))
+            self.ccode.append(
+                "\t%s = (char **)purple_%s_to_array(list, &%s_LEN);" % (
+                    name,
+                    type[0],
+                    name))
+            self.cparamsout.append(
+                "DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &%s, %s_LEN" % (name,
+                                                                    name))
+            if self.function.name not in constlists:
                 type_name = type[0].lower()[1:]
-                self.ccodeout.append("\tg_%s_foreach(list, (GFunc)g_free, NULL);" % type_name)
-                self.ccodeout.append("\tg_%s_free(list);" % type_name)
+                self.ccodeout.append(
+                    "\tg_%s_foreach(list, (GFunc)g_free, NULL);" % (
+                        type_name, ))
+                self.ccodeout.append("\tg_%s_free(list);" % (type_name, ))
             self.addouttype("as", name)
         else:
-            self.cdecls.append("\tdbus_int32_t *%s;" % name)
-            self.ccode.append("\tlist = %s;" % self.call)
-            self.ccode.append("\t%s = purple_dbusify_%s(list, &%s_LEN);" % \
-                         (name, type[0], name))
-            if (not (self.function.name in constlists)):
-                self.ccode.append("\tg_%s_free(list);" % type[0].lower()[1:])
-            self.cparamsout.append("DBUS_TYPE_ARRAY, DBUS_TYPE_INT32, &%s, %s_LEN" \
-                              % (name, name))
+            self.cdecls.append("\tdbus_int32_t *%s;" % (name, ))
+            self.ccode.append("\tlist = %s;" % (self.call, ))
+            self.ccode.append("\t%s = purple_dbusify_%s(list, &%s_LEN);" % (
+                name,
+                type[0],
+                name))
+            if self.function.name not in constlists:
+                type_name = type[0].lower()[1:]
+                self.ccode.append("\tg_%s_free(list);" % (type_name, ))
+            self.cparamsout.append(
+                "DBUS_TYPE_ARRAY, DBUS_TYPE_INT32, &%s, %s_LEN" % (name, name))
             self.addouttype("ai", name)
 
     # Special case for *_get_data functions
     def inputgetdata(self, type, name):
-        self.cdecls.append("\tsize_t %s = 0;" % name)
+        self.cdecls.append("\tsize_t %s = 0;" % (name, ))
         return True
+
     def outputgetdata(self, type, name):
         # This is a total hack, but self.call is set up before the parameters
         #  are processed, so we can't tell it to pass a parameter by reference.
-        self.call = "%s(%s)" % (self.function.name,
-                                ", ".join([(param.name, "&len")[param.name == "len"] for param in self.params]))
+        params = ', '.join('&len' if param.name == 'len' else param.name
+                           for param in self.params)
+        self.call = "%s(%s)" % (self.function.name, params)
 
-        self.cdecls.append("\tgconstpointer %s;" % name)
+        self.cdecls.append("\tgconstpointer %s;" % (name, ))
         self.ccode.append("\t%s = %s;" % (name, self.call))
-        self.cparamsout.append("DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &%s, %s" \
-                               % (name, "len"))
+        self.cparamsout.append("DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &%s, %s" % (
+            name,
+            "len"))
         self.addouttype("ay", name)
 
+
 class BindingSet(object):
-    regexp = r"^(\w[^()]*)\(([^()]*)\)\s*;\s*$";
+    regexp = r"^(\w[^()]*)\(([^()]*)\)\s*;\s*$"
 
     def __init__(self, inputfile, fprefix, output=None):
         self.inputiter = iter(inputfile)
-        self.functionregexp = \
-             re.compile("^%s(\w[^()]*)\(([^()]*)\)\s*;\s*$" % fprefix)    
+        self.functionregexp = re.compile(
+            "^%s(\w[^()]*)\(([^()]*)\)\s*;\s*$" % (fprefix, ))
         self.typeregexp = re.compile("^\w+\s*\*?\s*$")
         self.output = output
 
     def process(self):
-        print("/* Generated by %s.  Do not edit! */" % sys.argv[0],
+        print("/* Generated by %s.  Do not edit! */" % (sys.argv[0], ),
               file=self.output)
 
         for line in self.inputiter:
@@ -575,7 +609,8 @@
             # accumulate lines until the parentheses are balance or an
             # empty line has been encountered
             myline = line.strip()
-            while (myline.count("(") > myline.count(")")) or self.typeregexp.match(myline):
+            while (myline.count("(") > myline.count(")") or
+                    self.typeregexp.match(myline)):
                 newline = next(self.inputiter).strip()
                 if len(newline) == 0:
                     break
@@ -599,10 +634,8 @@
             try:
                 self.processfunction(functiontext, paramtexts)
             except MyException:
-#                sys.stderr.write(myline + "\n")
-                 pass
+                pass
             except:
-#                sys.stderr.write(myline + "\n")
                 raise
 
         self.flush()
@@ -613,17 +646,16 @@
         BindingSet.__init__(self, inputfile, fprefix, **kwargs)
         self.functions = []
 
-
     def processfunction(self, functiontext, paramtexts):
         binding = ServerBinding(functiontext, paramtexts, output=self.output)
         binding.process()
         self.functions.append((binding.function.name, binding.dparams))
-        
+
     def flush(self):
         print("static PurpleDBusBinding bindings_DBUS[] = { ",
               file=self.output)
         for function, params in self.functions:
-            print('{"%s", "%s", %s_DBUS},' % \
+            print('{"%s", "%s", %s_DBUS},' %
                   (ctopascal(function), params, function), file=self.output)
 
         print("{NULL, NULL, NULL}", file=self.output)
@@ -649,6 +681,7 @@
     def flush(self):
         pass
 
+
 # Main program
 
 parser = argparse.ArgumentParser()
--- a/libpurple/dbus-analyze-signals.py	Thu Sep 01 23:42:21 2016 -0400
+++ b/libpurple/dbus-analyze-signals.py	Thu Sep 01 23:58:47 2016 -0400
@@ -12,18 +12,20 @@
 import re
 import sys
 
+
 # List "excluded" contains signals that shouldn't be exported via
 # DBus.  If you remove a signal from this list, please make sure
 # that it does not break "make" with the configure option
 # "--enable-dbus" turned on.
 
-excluded = [\
+excluded = [
     # purple_dbus_signal_emit_purple prevents our "dbus-method-called"
     # signal from being propagated to dbus.
-	"dbus-method-called",
-    ]
+    "dbus-method-called",
+]
 
-registerregex = re.compile("purple_signal_register[^;]+\"([\w\-]+)\"[^;]+(purple_marshal_\w+)[^;]+;")
+registerregex = re.compile(
+    "purple_signal_register[^;]+\"([\w\-]+)\"[^;]+(purple_marshal_\w+)[^;]+;")
 nameregex = re.compile('[-_][a-z]')
 
 parser = argparse.ArgumentParser()
@@ -33,7 +35,7 @@
                     help='Output to file instead of stdout')
 cmd_args = parser.parse_args()
 
-print("/* Generated by %s.  Do not edit! */" % sys.argv[0],
+print("/* Generated by %s.  Do not edit! */" % (sys.argv[0], ),
       file=cmd_args.output)
 print("const char *dbus_signals = ", file=cmd_args.output)
 input = ''.join(list(fileinput.input(cmd_args.input)))
@@ -43,8 +45,8 @@
     if signal in excluded:
         continue
 
-    signal = nameregex.sub(lambda x:x.group()[1].upper(), '-'+signal)
-    print("\"    <signal name='%s'>\\n\"" % signal, file=cmd_args.output)
+    signal = nameregex.sub(lambda x: x.group()[1].upper(), '-' + signal)
+    print("\"    <signal name='%s'>\\n\"" % (signal, ), file=cmd_args.output)
 
     args = marshal.split('_')
     # ['purple', 'marshal', <return type>, '', args...]
@@ -64,7 +66,8 @@
                 type = 't'
             elif arg == "BOOLEAN":
                 type = 'b'
-            print("\"      <arg type='%s'/>\\n\"" % type, file=cmd_args.output)
+            print("\"      <arg type='%s'/>\\n\"" % (type, ),
+                  file=cmd_args.output)
 
     print("\"    </signal>\\n\"", file=cmd_args.output)
 
--- a/libpurple/dbus-analyze-types.py	Thu Sep 01 23:42:21 2016 -0400
+++ b/libpurple/dbus-analyze-types.py	Thu Sep 01 23:58:47 2016 -0400
@@ -21,12 +21,14 @@
 import re
 import sys
 
+
 def toprint(match, line):
     if args.verbatim:
         return line
     else:
         return args.pattern % match
 
+
 parser = argparse.ArgumentParser()
 parser.add_argument('input', nargs='*',
                     help='Input files (or stdin if not specified)')
@@ -40,11 +42,12 @@
                     help='Return full line of match instead of match itself')
 args = parser.parse_args()
 
-structregexp1 = re.compile(r"^(typedef\s+)?%s\s+\w+\s+(\w+)\s*;" % args.keyword)
-structregexp2 = re.compile(r"^(typedef\s+)?%s" % args.keyword)
+structregexp1 = re.compile(
+    r"^(typedef\s+)?%s\s+\w+\s+(\w+)\s*;" % (args.keyword, ))
+structregexp2 = re.compile(r"^(typedef\s+)?%s" % (args.keyword, ))
 structregexp3 = re.compile(r"^}\s+(\w+)\s*;")
 
-print("/* Generated by %s.  Do not edit! */" % sys.argv[0],
+print("/* Generated by %s.  Do not edit! */" % (sys.argv[0], ),
       file=args.output)
 
 myinput = fileinput.input(args.input)
--- a/libpurple/plugins/dbus-buddyicons-example.py	Thu Sep 01 23:42:21 2016 -0400
+++ b/libpurple/plugins/dbus-buddyicons-example.py	Thu Sep 01 23:58:47 2016 -0400
@@ -16,23 +16,25 @@
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
 #
 
 from __future__ import absolute_import, division, print_function
 
 import dbus
 
+
 bus = dbus.SessionBus()
-obj = bus.get_object("im.pidgin.purple.PurpleService", "/im/pidgin/purple/PurpleObject")
+obj = bus.get_object("im.pidgin.purple.PurpleService",
+                     "/im/pidgin/purple/PurpleObject")
 purple = dbus.Interface(obj, "im.pidgin.purple.PurpleInterface")
 
 node = purple.PurpleBlistGetRoot()
 while node != 0:
-	if purple.PurpleBlistNodeIsBuddy(node):
-		icon = purple.PurpleBuddyGetIcon(node)
-		if icon != 0:
-			print(purple.PurpleBuddyGetAlias(node))
-	node = purple.PurpleBlistNodeNext(node, 0)
+    if purple.PurpleBlistNodeIsBuddy(node):
+        icon = purple.PurpleBuddyGetIcon(node)
+        if icon != 0:
+            print(purple.PurpleBuddyGetAlias(node))
+    node = purple.PurpleBlistNodeNext(node, 0)
--- a/libpurple/plugins/startup.py	Thu Sep 01 23:42:21 2016 -0400
+++ b/libpurple/plugins/startup.py	Thu Sep 01 23:58:47 2016 -0400
@@ -16,16 +16,18 @@
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
 #
 
 from __future__ import absolute_import, division, print_function
 
+import os
 import sys
+
 import dbus
-import os
+
 
 if len(sys.argv) == 1:
     print("Usage:", sys.argv[0], "<purple-client> [arguments]")
@@ -34,23 +36,24 @@
 
 home = os.path.expanduser('~/.purple/')
 for arg in range(1, len(sys.argv[1:])):
-	if sys.argv[arg] == "-c":
-		home = os.path.expanduser(sys.argv[arg + 1])
-		break
+    if sys.argv[arg] == "-c":
+        home = os.path.expanduser(sys.argv[arg + 1])
+        break
 
 bus = dbus.SessionBus()
 
 try:
-	obj = bus.get_object("im.pidgin.purple.PurpleService", "/im/pidgin/purple/PurpleObject")
-	purple = dbus.Interface(obj, "im.pidgin.purple.PurpleInterface")
-	userdir = purple.PurpleUserDir()
-	if not os.path.isabs(userdir):
-		userdir = os.path.join(purple.PurpleHomeDir(), userdir)
-	if home == userdir:
-		print("Already running.")
-		purple.PurpleBlistShow()
-	else:
-		print("Starting client from a different home directory.")
-		raise
+    obj = bus.get_object("im.pidgin.purple.PurpleService",
+                         "/im/pidgin/purple/PurpleObject")
+    purple = dbus.Interface(obj, "im.pidgin.purple.PurpleInterface")
+    userdir = purple.PurpleUserDir()
+    if not os.path.isabs(userdir):
+        userdir = os.path.join(purple.PurpleHomeDir(), userdir)
+    if home == userdir:
+        print("Already running.")
+        purple.PurpleBlistShow()
+    else:
+        print("Starting client from a different home directory.")
+        raise
 except:
-	os.execlp(sys.argv[1], " ".join(sys.argv[2:]))
+    os.execlp(sys.argv[1], " ".join(sys.argv[2:]))
--- a/libpurple/purple-notifications-example	Thu Sep 01 23:42:21 2016 -0400
+++ b/libpurple/purple-notifications-example	Thu Sep 01 23:58:47 2016 -0400
@@ -10,19 +10,22 @@
 
 from __future__ import absolute_import, division, print_function
 
+import os
+
 import dbus
 import dbus.glib
 import dbus.decorators
 import gobject
-import os
+
 
 def ensureimconversation(conversation, account, name):
     if conversation != 0:
         return conversation
     else:
-        # 1 = PURPLE_CONV_IM 
+        # 1 = PURPLE_CONV_IM
         return purple.PurpleConversationNew(1, account, name)
 
+
 def receivedimmsg(account, name, message, conversation, flags):
     buddy = purple.PurpleFindBuddy(account, name)
     if buddy != 0:
@@ -43,14 +46,14 @@
         window = purple.PurpleConversationGetWindow(conversation)
         purple.PurpleConvWindowRaise(window)
 
-    if code == 103:                     # close 
+    if code == 103:                     # close
         purple.PurpleConversationDestroy(conversation)
 
     if code == 104:                     # abuse
         im = purple.PurpleConversationGetImData(conversation)
         purple.PurpleConvImSend(im, "Go away you f...")
-                                 
-        
+
+
 def buddysignedon(buddyid):
     alias = purple.PurpleBuddyGetAlias(buddyid)
     text = "%s is online" % alias
@@ -65,19 +68,20 @@
         name = purple.PurpleBuddyGetName(buddyid)
         account = purple.PurpleBuddyGetAccount(buddyid)
         purple.PurpleConversationNew(1, account, name)
-    
+
 
 bus = dbus.SessionBus()
-obj = bus.get_object("im.pidgin.purple.PurpleService", "/im/pidgin/purple/PurpleObject")
+obj = bus.get_object("im.pidgin.purple.PurpleService",
+                     "/im/pidgin/purple/PurpleObject")
 purple = dbus.Interface(obj, "im.pidgin.purple.PurpleInterface")
 
 bus.add_signal_receiver(receivedimmsg,
-                        dbus_interface = "im.pidgin.purple.PurpleInterface",
-                        signal_name = "ReceivedImMsg")
+                        dbus_interface="im.pidgin.purple.PurpleInterface",
+                        signal_name="ReceivedImMsg")
 
 bus.add_signal_receiver(buddysignedon,
-                        dbus_interface = "im.pidgin.purple.PurpleInterface",
-                        signal_name = "BuddySignedOn")
+                        dbus_interface="im.pidgin.purple.PurpleInterface",
+                        signal_name="BuddySignedOn")
 
 print("This is a simple purple notification server.")
 print("It shows notifications when your buddy signs on or you get an "
@@ -85,5 +89,3 @@
 
 loop = gobject.MainLoop()
 loop.run()
-
-
--- a/libpurple/purple-remote	Thu Sep 01 23:42:21 2016 -0400
+++ b/libpurple/purple-remote	Thu Sep 01 23:58:47 2016 -0400
@@ -3,29 +3,32 @@
 from __future__ import absolute_import, division, print_function
 
 import codecs
-import dbus
 import re
+import sys
 try:
     from urllib.parse import unquote
 except ImportError:
     from urllib import unquote
-import sys
+import xml.dom.minidom
 
-import xml.dom.minidom 
+import dbus
+
 
-sys.stdin = codecs.getwriter('utf-8')(sys.stdin);
-sys.stdout = codecs.getwriter('utf-8')(sys.stdout);
+sys.stdin = codecs.getwriter('utf-8')(sys.stdin)
+sys.stdout = codecs.getwriter('utf-8')(sys.stdout)
 
-xml.dom.minidom.Element.all   = xml.dom.minidom.Element.getElementsByTagName
+xml.dom.minidom.Element.all = xml.dom.minidom.Element.getElementsByTagName
 
 obj = None
 try:
-    obj = dbus.SessionBus().get_object("im.pidgin.purple.PurpleService", "/im/pidgin/purple/PurpleObject")
+    obj = dbus.SessionBus().get_object("im.pidgin.purple.PurpleService",
+                                       "/im/pidgin/purple/PurpleObject")
 except:
     pass
 
 purple = dbus.Interface(obj, "im.pidgin.purple.PurpleInterface")
 
+
 class CheckedObject(object):
     def __init__(self, obj):
         self.obj = obj
@@ -33,18 +36,20 @@
     def __getattr__(self, attr):
         return CheckedAttribute(self, attr)
 
+
 class CheckedAttribute(object):
     def __init__(self, cobj, attr):
         self.cobj = cobj
         self.attr = attr
-        
+
     def __call__(self, *args):
         result = self.cobj.obj.__getattr__(self.attr)(*args)
         if result == 0:
             raise Exception("Error: %s %s returned %s" %
                             (self.attr, args, result))
         return result
-            
+
+
 def show_help(requested=False):
     print("""This program uses D-Bus to communicate with purple.
 
@@ -83,26 +88,31 @@
     else:
         sys.exit(1)
 
+
 cpurple = CheckedObject(purple)
 
 urlregexp = r"^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?"
 
+
 def extendlist(list, length, fill):
     if len(list) < length:
         return list + [fill] * (length - len(list))
     else:
         return list
 
+
 def convert(value):
     try:
         return int(value)
     except:
         return value
 
+
 def findaccount(accountname, protocolname):
     try:
         # prefer connected accounts
-        account = cpurple.PurpleAccountsFindConnected(accountname, protocolname)
+        account = cpurple.PurpleAccountsFindConnected(accountname,
+                                                      protocolname)
         return account
     except:
         # try to get any account and connect it
@@ -110,7 +120,7 @@
         purple.PurpleAccountSetStatusVargs(account, "online", 1)
         purple.PurpleAccountConnect(account)
         return account
-    
+
 
 def execute(uri):
     match = re.match(urlregexp, uri)
@@ -124,14 +134,15 @@
     params = {}
     if paramstring is not None:
         for param in paramstring.split("&"):
-            key, value = extendlist(param.split("=",1), 2, "")
+            key, value = extendlist(param.split("=", 1), 2, "")
             params[key] = unquote(value)
 
     accountname = params.get("account", "")
 
     if command == "goim":
         account = findaccount(accountname, protocol)
-        conversation = cpurple.PurpleConversationNew(1, account, params["screenname"])
+        conversation = cpurple.PurpleConversationNew(1, account,
+                                                     params["screenname"])
         if "message" in params:
             im = cpurple.PurpleConversationGetImData(conversation)
             purple.PurpleConvImSend(im, params["message"])
@@ -144,8 +155,10 @@
 
     elif command == "addbuddy":
         account = findaccount(accountname, protocol)
-        return cpurple.PurpleBlistRequestAddBuddy(account, params["screenname"],
-                                              params.get("group", ""), "")
+        return cpurple.PurpleBlistRequestAddBuddy(account,
+                                                  params["screenname"],
+                                                  params.get("group", ""),
+                                                  "")
 
     elif command == "setstatus":
         current = purple.PurpleSavedstatusGetCurrent()
@@ -158,7 +171,7 @@
             status_id = purple.PurplePrimitiveGetIdFromType(status_type)
 
         if "message" in params:
-            message = params["message"];
+            message = params["message"]
         else:
             message = purple.PurpleSavedstatusGetMessage(current)
 
@@ -168,7 +181,8 @@
             for account in accounts:
                 status = purple.PurpleAccountGetStatus(account, status_id)
                 type = purple.PurpleStatusGetType(status)
-                purple.PurpleSavedstatusSetSubstatus(current, account, type, message)
+                purple.PurpleSavedstatusSetSubstatus(current, account, type,
+                                                     message)
                 purple.PurpleSavedstatusActivateForAccount(current, account)
         else:
             saved = purple.PurpleSavedstatusNew("", status_type)
@@ -212,10 +226,11 @@
                 fargs.append(convert(arg.strip()))
             return purple.__getattr__(name)(*fargs)
         else:
-            # introspect the object to get parameter names and types
-            # this is slow because the entire introspection info must be downloaded
-            data = dbus.Interface(obj, "org.freedesktop.DBus.Introspectable").\
-                   Introspect()
+            # Introspect the object to get parameter names and types. This is
+            # slow because the entire introspection info must be downloaded.
+            interface = dbus.Interface(obj,
+                                       "org.freedesktop.DBus.Introspectable")
+            data = interface.Introspect()
             introspect = xml.dom.minidom.parseString(data).documentElement
             for method in introspect.all("method"):
                 if command == method.getAttribute("name"):
@@ -229,21 +244,23 @@
                             elif type == "i":
                                 methodparams.append(int(value))
                             else:
-                                raise Exception("Don't know how to handle type \"%s\"" % type)
+                                raise Exception(
+                                    "Don't know how to handle type \"%s\"" % (
+                                        type, ))
                     return purple.__getattr__(command)(*methodparams)
             show_help()
 
+
 if len(sys.argv) == 1:
     show_help()
-elif (sys.argv[1] == "--help" or sys.argv[1] == "-h"):
+elif sys.argv[1] == "--help" or sys.argv[1] == "-h":
     show_help(True)
-elif (obj == None):
+elif obj is None:
     print("No existing libpurple instance detected.")
-    sys.exit(1);
-    
+    sys.exit(1)
+
 for arg in sys.argv[1:]:
     output = execute(arg)
 
-    if (output != None):
+    if output is not None:
         print(output)
-
--- a/libpurple/purple-url-handler	Thu Sep 01 23:42:21 2016 -0400
+++ b/libpurple/purple-url-handler	Thu Sep 01 23:58:47 2016 -0400
@@ -11,6 +11,7 @@
 except ImportError:
     from urllib import unquote_plus
 
+
 bus = dbus.SessionBus()
 obj = None
 try:
@@ -18,10 +19,12 @@
                          "/im/pidgin/purple/PurpleObject")
 except dbus.DBusException as e:
     if e._dbus_error_name == "org.freedesktop.DBus.Error.ServiceUnknown":
-        print("Error: no libpurple-powered client is running. Try starting Pidgin or Finch.")
+        print("Error: no libpurple-powered client is running. "
+              "Try starting Pidgin or Finch.")
         sys.exit(1)
 purple = dbus.Interface(obj, "im.pidgin.purple.PurpleInterface")
 
+
 class CheckedObject(object):
     def __init__(self, obj):
         self.obj = obj
@@ -29,6 +32,7 @@
     def __getattr__(self, attr):
         return CheckedAttribute(self, attr)
 
+
 class CheckedAttribute(object):
     def __init__(self, cobj, attr):
         self.cobj = cobj
@@ -44,29 +48,34 @@
         sys.stderr = real_stderr
 
 # This can be useful for debugging.
-#        if (result == 0):
-#            print "Error: " + self.attr + " " + str(args) + " returned " + str(result)
+#        if result == 0:
+#            print("Error:", self.attr, str(args), "returned", str(result))
 
         return result
 
+
 cpurple = CheckedObject(purple)
 
+
 def extendlist(list, length, fill):
     if len(list) < length:
         return list + [fill] * (length - len(list))
     else:
         return list
 
+
 def convert(value):
     try:
         return int(value)
     except:
         return value
 
+
 def account_not_found():
     print("No matching account found.")
     sys.exit(1)
 
+
 def bring_account_online(account):
     if not cpurple.PurpleAccountIsConnected(account):
         # The last argument is meant to be a GList * but the D-Bus binding
@@ -75,11 +84,14 @@
         purple.PurpleAccountSetStatusList(account, "online", 1, 0)
         purple.PurpleAccountConnect(account)
 
+
 def findaccount(protocolname, accountname="", matcher=None):
     if matcher:
         for account in cpurple.PurpleAccountsGetAll():
-            if (protocolname != cpurple.PurpleAccountGetProtocolId(account)) or \
-               (accountname != "" and accountname != cpurple.PurpleAccountGetUsername(account)):
+            if protocolname != cpurple.PurpleAccountGetProtocolId(account):
+                continue
+            if (accountname != "" and
+                    accountname != cpurple.PurpleAccountGetUsername(account)):
                 continue
             if matcher(account):
                 bring_account_online(account)
@@ -88,37 +100,43 @@
 
     # prefer connected accounts
     account = cpurple.PurpleAccountsFindConnected(accountname, protocolname)
-    if (account != 0):
+    if account != 0:
         return account
 
     # try to get any account and connect it
     account = cpurple.PurpleAccountsFindAny(accountname, protocolname)
-    if (account == 0):
+    if account == 0:
         account_not_found()
 
     bring_account_online(account)
     return account
 
+
 def goim(account, screenname, message=None):
     # XXX: 1 == PURPLE_CONV_TYPE_IM
     conversation = cpurple.PurpleConversationNew(1, account, screenname)
     if message:
         purple.PurpleConvSendConfirm(conversation, message)
 
+
 def gochat(account, params, message=None):
     connection = cpurple.PurpleAccountGetConnection(account)
     purple.PurpleServJoinChat(connection, params)
 
-    if message != None:
-    	for i in range(20):
+    if message is not None:
+        for i in range(20):
             # XXX: 2 == PURPLE_CONV_TYPE_CHAT
-            conversation = purple.PurpleFindConversationWithAccount(2, params.get("channel", params.get("room")), account)
+            conversation = purple.PurpleFindConversationWithAccount(
+                2,
+                params.get("channel", params.get("room")),
+                account)
             if conversation:
                 purple.PurpleConvSendConfirm(conversation, message)
                 break
             else:
                 time.sleep(0.5)
 
+
 def addbuddy(account, screenname, group="", alias=""):
     cpurple.PurpleBlistRequestAddBuddy(account, screenname, group, alias)
 
@@ -127,7 +145,7 @@
     protocol = "prpl-aim"
     match = re.match(r"^aim:([^?]*)(\?(.*))", uri)
     if not match:
-        print("Invalid aim URI: %s" % uri)
+        print("Invalid aim URI: %s" % (uri, ))
         return
 
     command = unquote_plus(match.group(1))
@@ -149,22 +167,24 @@
     elif command.lower() == "addbuddy":
         addbuddy(account, screenname, params.get("group", ""))
 
+
 def gg(uri):
     protocol = "prpl-gg"
     match = re.match(r"^gg:(.*)", uri)
     if not match:
-        print("Invalid gg URI: %s" % uri)
+        print("Invalid gg URI: %s" % (uri, ))
         return
 
     screenname = unquote_plus(match.group(1))
     account = findaccount(protocol)
     goim(account, screenname)
 
+
 def icq(uri):
     protocol = "prpl-icq"
     match = re.match(r"^icq:([^?]*)(\?(.*))", uri)
     if not match:
-        print("Invalid icq URI: %s" % uri)
+        print("Invalid icq URI: %s" % (uri, ))
         return
 
     command = unquote_plus(match.group(1))
@@ -186,11 +206,12 @@
     elif command.lower() == "addbuddy":
         addbuddy(account, screenname, params.get("group", ""))
 
+
 def irc(uri):
     protocol = "prpl-irc"
     match = re.match(r"^irc:(//([^/]*))?/?([^?]*)(\?(.*))?", uri)
     if not match:
-        print("Invalid irc URI: %s" % uri)
+        print("Invalid irc URI: %s" % (uri, ))
         return
 
     server = unquote_plus(match.group(2) or "")
@@ -213,24 +234,31 @@
 
     def correct_server(account):
         username = cpurple.PurpleAccountGetUsername(account)
-        return ((server == "") or ("@" in username) and (server == (username.split("@"))[1]))
+        return (server == "" or
+                "@" in username and server == username.split("@")[1])
 
     account = findaccount(protocol, matcher=correct_server)
 
-    if (target != ""):
-        if (isnick):
-            goim(account, unquote_plus(target.split(",")[0]), params.get("msg"))
+    if target != "":
+        if isnick:
+            goim(account, unquote_plus(target.split(",")[0]),
+                 params.get("msg"))
         else:
             channel = unquote_plus(target.split(",")[0])
             if channel[0] != "#":
                 channel = "#" + channel
-            gochat(account, {"server": server, "channel": channel, "password": params.get("key", "")}, params.get("msg"))
+            gochat(account,
+                   {"server": server,
+                    "channel": channel,
+                    "password": params.get("key", "")},
+                   params.get("msg"))
+
 
 def msnim(uri):
     protocol = "prpl-msn"
     match = re.match(r"^msnim:([^?]*)(\?(.*))", uri)
     if not match:
-        print("Invalid msnim URI: %s" % uri)
+        print("Invalid msnim URI: %s" % (uri, ))
         return
 
     command = unquote_plus(match.group(1))
@@ -249,26 +277,30 @@
     elif command.lower() == "add":
         addbuddy(account, screenname)
 
+
 def sip(uri):
     protocol = "prpl-simple"
     match = re.match(r"^sip:(.*)", uri)
     if not match:
-        print("Invalid sip URI: %s" % uri)
+        print("Invalid sip URI: %s" % (uri, ))
         return
 
     screenname = unquote_plus(match.group(1))
     account = findaccount(protocol)
     goim(account, screenname)
 
+
 def xmpp(uri):
     protocol = "prpl-jabber"
-    match = re.match(r"^xmpp:(//([^/?#]*)/?)?([^?#]*)(\?([^;#]*)(;([^#]*))?)?(#(.*))?", uri)
+    match = re.match(
+        r"^xmpp:(//([^/?#]*)/?)?([^?#]*)(\?([^;#]*)(;([^#]*))?)?(#(.*))?",
+        uri)
     if not match:
-        print("Invalid xmpp URI: %s" % uri)
+        print("Invalid xmpp URI: %s" % (uri, ))
         return
 
     tmp = match.group(2)
-    if (tmp):
+    if tmp:
         accountname = unquote_plus(tmp)
     else:
         accountname = ""
@@ -276,7 +308,7 @@
     screenname = unquote_plus(match.group(3))
 
     tmp = match.group(5)
-    if (tmp):
+    if tmp:
         command = unquote_plus(tmp)
     else:
         command = ""
@@ -296,15 +328,17 @@
         room, server = screenname.split("@")
         gochat(account, {"room": room, "server": server})
     elif command.lower() == "roster":
-        addbuddy(account, screenname, params.get("group", ""), params.get("name", ""))
+        addbuddy(account, screenname, params.get("group", ""),
+                 params.get("name", ""))
     else:
         goim(account, screenname)
 
+
 def gtalk(uri):
     protocol = "prpl-jabber"
     match = re.match(r"^gtalk:([^?]*)(\?(.*))", uri)
     if not match:
-        print("Invalid gtalk URI: %s" % uri)
+        print("Invalid gtalk URI: %s" % (uri, ))
         return
 
     command = unquote_plus(match.group(1))
@@ -325,11 +359,12 @@
         # XXX V&V prompt to establish call
         goim(account, jid)
 
+
 def ymsgr(uri):
     protocol = "prpl-yahoo"
     match = re.match(r"^ymsgr:([^?]*)(\?([^&]*)(&(.*))?)", uri)
     if not match:
-        print("Invalid ymsgr URI: %s" % uri)
+        print("Invalid ymsgr URI: %s" % (uri, ))
         return
 
     command = unquote_plus(match.group(1))
@@ -353,8 +388,8 @@
 
 def main(argv=sys.argv):
     if len(argv) != 2 or argv[1] == "--help" or argv[1] == "-h":
-        print("Usage: %s URI" % argv[0])
-        print("Example: %s \"xmpp:romeo@montague.net?message\"" % argv[0])
+        print("Usage: %s URI" % (argv[0], ))
+        print("Example: %s \"xmpp:romeo@montague.net?message\"" % (argv[0], ))
 
         if len(argv) != 2:
             sys.exit(1)
@@ -384,10 +419,11 @@
         elif type == "ymsgr":
             ymsgr(uri)
         else:
-            print("Unknown protocol: %s" % type)
+            print("Unknown protocol: %s" % (type, ))
     except dbus.DBusException as e:
         print("Error: %s" % (str(e), ))
         sys.exit(1)
 
+
 if __name__ == "__main__":
     main()

mercurial