Merge lp:~elachuni/software-center/pep8-test-part20 into lp:software-center

[Anthony Lenton]

This branch makes all files under softwarecenter/backend/piston/ and softwarecenter/backend/installbackend_impl/ pass the pep8 test.

[Kiwinote (kiwinote)]

review: Approve

=== modified file 'softwarecenter/backend/installbackend_impl/aptd.py'
--- softwarecenter/backend/installbackend_impl/aptd.py	2012-03-16 14:36:05 +0000
+++ softwarecenter/backend/installbackend_impl/aptd.py	2012-03-16 20:20:25 +0000
@@ -41,7 +41,7 @@
 
 from softwarecenter.db.application import Application
 from softwarecenter.backend.transactionswatcher import (
-    BaseTransactionsWatcher, 
+    BaseTransactionsWatcher,
     BaseTransaction,
     TransactionFinishedResult,
     TransactionProgress)
@@ -52,6 +52,8 @@
 # its important that we only have a single dbus BusConnection
 # per address when using the fake dbus aptd
 buses = {}
+
+
 def get_dbus_bus():
     if "SOFTWARE_CENTER_APTD_FAKE" in os.environ:
         global buses
@@ -63,6 +65,7 @@
         bus = dbus.SystemBus()
     return bus
 
+
 class FakePurchaseTransaction(object):
     def __init__(self, app, iconname):
         self.pkgname = app.pkgname
@@ -70,6 +73,7 @@
         self.iconname = iconname
         self.progress = 0
 
+
 class AptdaemonTransaction(BaseTransaction):
     def __init__(self, trans):
         self._trans = trans
@@ -126,9 +130,10 @@
             trans = AptdaemonTransaction(trans)
         return real_handler(trans, *args)
 
+
 class AptdaemonTransactionsWatcher(BaseTransactionsWatcher):
-    """ 
-    base class for objects that need to watch the aptdaemon 
+    """
+    base class for objects that need to watch the aptdaemon
     for transaction changes. it registers a handler for the daemon
     going away and reconnects when it appears again
     """
@@ -144,7 +149,7 @@
         #print "_register_active_transactions_watch", connection
         bus = get_dbus_bus()
         apt_daemon = client.get_aptdaemon(bus=bus)
-        apt_daemon.connect_to_signal("ActiveTransactionsChanged", 
+        apt_daemon.connect_to_signal("ActiveTransactionsChanged",
                                      self._on_transactions_changed)
         current, queued = apt_daemon.GetActiveTransactions()
         self._on_transactions_changed(current, queued)
@@ -158,54 +163,54 @@
             trans = client.get_transaction(tid)
             return AptdaemonTransaction(trans)
         except dbus.DBusException:
-            return None
+            pass
 
 
 class AptdaemonBackend(GObject.GObject, InstallBackend):
     """ software center specific code that interacts with aptdaemon """
 
-    __gsignals__ = {'transaction-started':(GObject.SIGNAL_RUN_FIRST,
+    __gsignals__ = {'transaction-started': (GObject.SIGNAL_RUN_FIRST,
                                             GObject.TYPE_NONE,
-                                            (str,str,str,str)),
+                                            (str, str, str, str)),
                     # emits a TransactionFinished object
-                    'transaction-finished':(GObject.SIGNAL_RUN_FIRST,
-                                            GObject.TYPE_NONE,
-                                            (GObject.TYPE_PYOBJECT, )),
-                    'transaction-stopped':(GObject.SIGNAL_RUN_FIRST,
+                    'transaction-finished': (GObject.SIGNAL_RUN_FIRST,
+                                             GObject.TYPE_NONE,
+                                             (GObject.TYPE_PYOBJECT, )),
+                    'transaction-stopped': (GObject.SIGNAL_RUN_FIRST,
                                             GObject.TYPE_NONE,
                                             (GObject.TYPE_PYOBJECT,)),
-                    'transactions-changed':(GObject.SIGNAL_RUN_FIRST,
-                                            GObject.TYPE_NONE,
-                                            (GObject.TYPE_PYOBJECT, )),
-                    'transaction-progress-changed':(GObject.SIGNAL_RUN_FIRST,
-                                                    GObject.TYPE_NONE,
-                                                    (str,int,)),
+                    'transactions-changed': (GObject.SIGNAL_RUN_FIRST,
+                                             GObject.TYPE_NONE,
+                                             (GObject.TYPE_PYOBJECT, )),
+                    'transaction-progress-changed': (GObject.SIGNAL_RUN_FIRST,
+                                                     GObject.TYPE_NONE,
+                                                     (str, int,)),
                     # the number/names of the available channels changed
-                    'channels-changed':(GObject.SIGNAL_RUN_FIRST,
+                    'channels-changed': (GObject.SIGNAL_RUN_FIRST,
+                                         GObject.TYPE_NONE,
+                                         (bool,)),
+                    # cache reload emits this specific signal as well
+                    'reload-finished': (GObject.SIGNAL_RUN_FIRST,
                                         GObject.TYPE_NONE,
-                                        (bool,)),
-                    # cache reload emits this specific signal as well
-                    'reload-finished':(GObject.SIGNAL_RUN_FIRST,
-                                       GObject.TYPE_NONE,
-                                       (GObject.TYPE_PYOBJECT, bool,)),
+                                        (GObject.TYPE_PYOBJECT, bool,)),
                     }
 
     def __init__(self):
         GObject.GObject.__init__(self)
-        
+
         bus = get_dbus_bus()
         self.aptd_client = client.AptClient(bus=bus)
         self.pending_transactions = {}
         self._transactions_watcher = AptdaemonTransactionsWatcher()
         self._transactions_watcher.connect("lowlevel-transactions-changed",
-                                           self._on_lowlevel_transactions_changed)
+            self._on_lowlevel_transactions_changed)
         # dict of pkgname -> FakePurchaseTransaction
         self.pending_purchases = {}
         self._progress_signal = None
         self._logger = logging.getLogger("softwarecenter.backend")
         # the AptdaemonBackendUI code
         self.ui = None
-    
+
     def _axi_finished(self, res):
         self.emit("channels-changed", res)
 
@@ -216,7 +221,7 @@
         # axi is optional, so just do nothing if its not installed
         try:
             axi = dbus.Interface(
-                system_bus.get_object("org.debian.AptXapianIndex","/"),
+                system_bus.get_object("org.debian.AptXapianIndex", "/"),
                 "org.debian.AptXapianIndex")
         except dbus.DBusException as e:
             self._logger.warning("axi can not be updated '%s'" % e)
@@ -234,22 +239,26 @@
     def fix_broken_depends(self):
         try:
             trans = yield self.aptd_client.fix_broken_depends(defer=True)
-            self.emit("transaction-started", "", "", trans.tid, TransactionTypes.REPAIR)
+            self.emit("transaction-started", "", "", trans.tid,
+                TransactionTypes.REPAIR)
             yield self._run_transaction(trans, None, None, None)
         except Exception as error:
             self._on_trans_error(error)
 
     # FIXME: upgrade add-ons here
     @inline_callbacks
-    def upgrade(self, app, iconname, addons_install=[], addons_remove=[], metadata=None):
+    def upgrade(self, app, iconname, addons_install=[], addons_remove=[],
+        metadata=None):
         """ upgrade a single package """
         pkgname = app.pkgname
         appname = app.appname
         try:
             trans = yield self.aptd_client.upgrade_packages([pkgname],
                                                             defer=True)
-            self.emit("transaction-started", pkgname, appname, trans.tid, TransactionTypes.UPGRADE)
-            yield self._run_transaction(trans, pkgname, appname, iconname, metadata)
+            self.emit("transaction-started", pkgname, appname, trans.tid,
+                TransactionTypes.UPGRADE)
+            yield self._run_transaction(trans, pkgname, appname, iconname,
+                metadata)
         except Exception as error:
             self._on_trans_error(error, pkgname)
 
@@ -257,9 +266,10 @@
 #    @inline_callbacks
 #    def _simulate_remove_multiple(self, pkgnames):
 #        try:
-#            trans = yield self.aptd_client.remove_packages(pkgnames, 
+#            trans = yield self.aptd_client.remove_packages(pkgnames,
 #                                                           defer=True)
-#            trans.connect("dependencies-changed", self._on_dependencies_changed)
+#            trans.connect("dependencies-changed",
+#                self._on_dependencies_changed)
 #        except Exception:
 #            logging.exception("simulate_remove")
 #        return_value(trans)
@@ -278,22 +288,25 @@
 #                gtk.main_iteration()
 #            time.sleep(0.01)
 
-    
     @inline_callbacks
-    def remove(self, app, iconname, addons_install=[], addons_remove=[], metadata=None):
+    def remove(self, app, iconname, addons_install=[], addons_remove=[],
+        metadata=None):
         """ remove a single package """
         pkgname = app.pkgname
         appname = app.appname
         try:
             trans = yield self.aptd_client.remove_packages([pkgname],
                                                            defer=True)
-            self.emit("transaction-started", pkgname, appname, trans.tid, TransactionTypes.REMOVE)
-            yield self._run_transaction(trans, pkgname, appname, iconname, metadata)
+            self.emit("transaction-started", pkgname, appname, trans.tid,
+                TransactionTypes.REMOVE)
+            yield self._run_transaction(trans, pkgname, appname, iconname,
+                metadata)
         except Exception as error:
             self._on_trans_error(error, pkgname)
 
     @inline_callbacks
-    def remove_multiple(self, apps, iconnames, addons_install=[], addons_remove=[], metadatas=None):
+    def remove_multiple(self, apps, iconnames, addons_install=[],
+        addons_remove=[], metadatas=None):
         """ queue a list of packages for removal  """
         if metadatas == None:
             metadatas = []
@@ -303,7 +316,8 @@
             yield self.remove(app, iconname, metadata)
 
     @inline_callbacks
-    def install(self, app, iconname, filename=None, addons_install=[], addons_remove=[], metadata=None, force=False):
+    def install(self, app, iconname, filename=None, addons_install=[],
+        addons_remove=[], metadata=None, force=False):
         """Install a single package from the archive
            If filename is given a local deb package is installed instead.
         """
@@ -317,23 +331,26 @@
                 # force means on lintian failure
                 trans = yield self.aptd_client.install_file(
                     filename, force=force, defer=True)
-                self.emit("transaction-started", pkgname, appname, trans.tid, TransactionTypes.INSTALL)
+                self.emit("transaction-started", pkgname, appname, trans.tid,
+                    TransactionTypes.INSTALL)
                 yield trans.set_meta_data(sc_filename=filename, defer=True)
             else:
                 install = [pkgname] + addons_install
                 remove = addons_remove
-                reinstall = remove = purge = upgrade =downgrade = []
+                reinstall = remove = purge = upgrade = downgrade = []
                 trans = yield self.aptd_client.commit_packages(
-                    install, reinstall, remove, purge, upgrade, downgrade, 
+                    install, reinstall, remove, purge, upgrade, downgrade,
                     defer=True)
-                self.emit("transaction-started", pkgname, appname, trans.tid, TransactionTypes.INSTALL)
+                self.emit("transaction-started", pkgname, appname, trans.tid,
+                    TransactionTypes.INSTALL)
             yield self._run_transaction(
                 trans, pkgname, appname, iconname, metadata)
         except Exception as error:
             self._on_trans_error(error, pkgname)
 
     @inline_callbacks
-    def install_multiple(self, apps, iconnames, addons_install=[], addons_remove=[], metadatas=None):
+    def install_multiple(self, apps, iconnames, addons_install=[],
+        addons_remove=[], metadatas=None):
         """ queue a list of packages for install  """
         if metadatas == None:
             metadatas = []
@@ -341,20 +358,22 @@
                 metadatas.append(None)
         for app, iconname, metadata in zip(apps, iconnames, metadatas):
             yield self.install(app, iconname, metadata=metadata)
-            
+
     @inline_callbacks
-    def apply_changes(self, app, iconname, addons_install=[], addons_remove=[], metadata=None):
+    def apply_changes(self, app, iconname, addons_install=[],
+        addons_remove=[], metadata=None):
         """ install and remove add-ons """
         pkgname = app.pkgname
         appname = app.appname
         try:
             install = addons_install
             remove = addons_remove
-            reinstall = remove = purge = upgrade =downgrade = []
+            reinstall = remove = purge = upgrade = downgrade = []
             trans = yield self.aptd_client.commit_packages(
-                install, reinstall, remove, purge, upgrade, downgrade, 
+                install, reinstall, remove, purge, upgrade, downgrade,
                 defer=True)
-            self.emit("transaction-started", pkgname, appname, trans.tid, TransactionTypes.APPLY)
+            self.emit("transaction-started", pkgname, appname, trans.tid,
+                TransactionTypes.APPLY)
             yield self._run_transaction(trans, pkgname, appname, iconname)
         except Exception as error:
             self._on_trans_error(error)
@@ -365,12 +384,12 @@
         # check if the sourcespart is there, if not, do a full reload
         # this can happen when the "partner" repository is added, it
         # will be in the main sources.list already and this means that
-        # aptsources will just enable it instead of adding a extra 
+        # aptsources will just enable it instead of adding a extra
         # sources.list.d file (LP: #666956)
         d = apt_pkg.config.find_dir("Dir::Etc::sourceparts")
         if (not sources_list or
             not os.path.exists(os.path.join(d, sources_list))):
-            sources_list=""
+            sources_list = ""
         try:
             trans = yield self.aptd_client.update_cache(
                 sources_list=sources_list, defer=True)
@@ -404,18 +423,18 @@
                 continue
             sourcepart = os.path.basename(channelfile)
             yield self.add_sources_list_entry(entry, sourcepart)
-            keyfile = channelfile.replace(".list",".key")
+            keyfile = channelfile.replace(".list", ".key")
             if os.path.exists(keyfile):
-                trans = yield self.aptd_client.add_vendor_key_from_file(keyfile, wait=True)
+                trans = yield self.aptd_client.add_vendor_key_from_file(
+                    keyfile, wait=True)
                 # don't use self._run_transaction() here, to avoid sending
                 # uneeded signals
                 yield trans.run(defer=True)
         yield self.reload(sourcepart)
 
     @inline_callbacks
-    def add_vendor_key_from_keyserver(self, keyid, 
-                                      keyserver="hkp://keyserver.ubuntu.com:80/",
-                                      metadata=None):
+    def add_vendor_key_from_keyserver(self, keyid,
+        keyserver="hkp://keyserver.ubuntu.com:80/", metadata=None):
         # strip the keysize
         if "/" in keyid:
             keyid = keyid.split("/")[1]
@@ -452,8 +471,8 @@
 
     @inline_callbacks
     def authenticate_for_purchase(self):
-        """ 
-        helper that authenticates with aptdaemon for a purchase operation 
+        """
+        helper that authenticates with aptdaemon for a purchase operation
         """
         bus = get_dbus_bus()
         name = bus.get_unique_name()
@@ -462,12 +481,13 @@
         yield policykit1.check_authorization_by_name(name, action, flags=flags)
 
     @inline_callbacks
-    def add_license_key(self, license_key, license_key_path, license_key_oauth, pkgname):
+    def add_license_key(self, license_key, license_key_path,
+        license_key_oauth, pkgname):
         """ add a license key for a purchase. """
         self._logger.debug(
             "adding license_key for pkg '%s' of len: %i" % (
                 pkgname, len(license_key)))
-        
+
         # HOME based license keys
         if license_key_path and license_key_path.startswith("~"):
             # check if its inside HOME and if so, just create it
@@ -503,19 +523,19 @@
                                          license_key_path,
                                          json_oauth_token=None,
                                          purchase=True):
-        """ 
+        """
         a convenience method that combines all of the steps needed
         to install a for-pay application, including adding the
         source entry and the vendor key, reloading the package list,
         and finally installing the specified application once the
         package list reload has completed.
         """
-        self.emit("transaction-started", app.pkgname, app.appname, "FIXME-NEED-ID-HERE", TransactionTypes.INSTALL)
-        self._logger.info("add_repo_add_key_and_install_app() '%s' '%s' '%s'"% (
-                # re.sub() out the password from the log
-                re.sub("deb https://.*@", "", deb_line),
-                signing_key_id, 
-                app))
+        self.emit("transaction-started", app.pkgname, app.appname,
+            "FIXME-NEED-ID-HERE", TransactionTypes.INSTALL)
+        self._logger.info("add_repo_add_key_and_install_app() '%s' '%s' '%s'" %
+            (re.sub("deb https://.*@", "", deb_line),  # strip out password
+            signing_key_id,
+            app))
 
         if purchase:
             # pre-authenticate
@@ -537,15 +557,17 @@
 
         # add the metadata early, add_sources_list_entry is a transaction
         # too
-        trans_metadata = {'sc_add_repo_and_install_appname' : app.appname, 
-                          'sc_add_repo_and_install_pkgname' : app.pkgname,
-                          'sc_add_repo_and_install_deb_line' : deb_line,
-                          'sc_iconname' : iconname,
-                          'sc_add_repo_and_install_try' : "1",
-                          'sc_add_repo_and_install_license_key' : license_key or "",
-                          'sc_add_repo_and_install_license_key_path' : license_key_path or "",
-                          'sc_add_repo_and_install_license_key_token' : json_oauth_token or "",
-                         }
+        trans_metadata = {
+            'sc_add_repo_and_install_appname': app.appname,
+            'sc_add_repo_and_install_pkgname': app.pkgname,
+            'sc_add_repo_and_install_deb_line': deb_line,
+            'sc_iconname': iconname,
+            'sc_add_repo_and_install_try': "1",
+            'sc_add_repo_and_install_license_key': license_key or "",
+            'sc_add_repo_and_install_license_key_path': license_key_path or "",
+            'sc_add_repo_and_install_license_key_token': \
+                json_oauth_token or "",
+        }
 
         self._logger.info("add_sources_list_entry()")
         sourcepart = yield self.add_sources_list_entry(deb_line)
@@ -560,8 +582,9 @@
         yield self._reload_for_commercial_repo(app, trans_metadata, sourcepart)
 
     @inline_callbacks
-    def _reload_for_commercial_repo_defer(self, app, trans_metadata, sources_list):
-        """ 
+    def _reload_for_commercial_repo_defer(self, app, trans_metadata,
+        sources_list):
+        """
         helper that reloads and registers a callback for when the reload is
         finished
         """
@@ -570,7 +593,7 @@
         # otherwise the daemon will fail because he does not know
         # the new package name yet
         self.connect("reload-finished",
-                     self._on_reload_for_add_repo_and_install_app_finished, 
+                     self._on_reload_for_add_repo_and_install_app_finished,
                      trans_metadata, app)
         # reload to ensure we have the new package data
         yield self.reload(sources_list=sources_list, metadata=trans_metadata)
@@ -588,29 +611,34 @@
         return False
 
     @inline_callbacks
-    def _on_reload_for_add_repo_and_install_app_finished(self, backend, trans, 
-                                                         result, metadata, app):
-        """ 
+    def _on_reload_for_add_repo_and_install_app_finished(self, backend, trans,
+        result, metadata, app):
+        """
         callback that is called once after reload was queued
         and will trigger the install of the for-pay package itself
         (after that it will automatically de-register)
         """
-        #print "_on_reload_for_add_repo_and_install_app_finished", trans, result, backend, self._reload_signal_id
-        self._logger.info("_on_reload_for_add_repo_and_install_app_finished() %s %s %s" % (trans, result, app))
+        #print "_on_reload_for_add_repo_and_install_app_finished", trans, \
+        #    result, backend, self._reload_signal_id
+        self._logger.info("_on_reload_for_add_repo_and_install_app_finished() "
+            "%s %s %s" % (trans, result, app))
 
         # check if this is the transaction we waiting for
         key = "sc_add_repo_and_install_pkgname"
-        if not (key in trans.meta_data and trans.meta_data[key] == app.pkgname):
+        if not (key in trans.meta_data and
+            trans.meta_data[key] == app.pkgname):
             return_value(None)
 
         # get the debline and check if we have a release.gpg file
         deb_line = trans.meta_data["sc_add_repo_and_install_deb_line"]
         license_key = trans.meta_data["sc_add_repo_and_install_license_key"]
-        license_key_path = trans.meta_data["sc_add_repo_and_install_license_key_path"]
-        license_key_oauth = trans.meta_data["sc_add_repo_and_install_license_key_token"]  
+        license_key_path = trans.meta_data[
+            "sc_add_repo_and_install_license_key_path"]
+        license_key_oauth = trans.meta_data[
+            "sc_add_repo_and_install_license_key_token"]
         release_filename = release_filename_in_lists_from_deb_line(deb_line)
         lists_dir = apt_pkg.config.find_dir("Dir::State::lists")
-        release_signature = os.path.join(lists_dir, release_filename)+".gpg"
+        release_signature = os.path.join(lists_dir, release_filename) + ".gpg"
         self._logger.info("looking for '%s'" % release_signature)
         # no Release.gpg in the newly added repository, try again,
         # this can happen e.g. on odd network proxies
@@ -625,15 +653,15 @@
         # FIXME: this logic will *fail* if the sources.list of the user
         #        was broken before
 
-        # run install action if the repo was added successfully 
+        # run install action if the repo was added successfully
         if result:
             self.emit("channels-changed", True)
 
             # we use aptd_client.install_packages() here instead
-            # of just 
+            # of just
             #  self.install(app, "", metadata=metadata)
-            # go get less authentication prompts (because of the 03_auth_me_less
-            # patch in aptdaemon)
+            # go get less authentication prompts (because of the
+            # 03_auth_me_less patch in aptdaemon)
             try:
                 self._logger.info("install_package()")
                 trans = yield self.aptd_client.install_packages(
@@ -648,7 +676,7 @@
             #        but I wonder if we should ease that restriction
             if license_key and not os.path.exists(license_key_path):
                 yield self.add_license_key(
-                    license_key, license_key_path, license_key_oauth, 
+                    license_key, license_key_path, license_key_oauth,
                     app.pkgname)
 
         else:
@@ -668,14 +696,16 @@
             # whole re-try machinery will not survive anyway if the local
             # s-c instance is closed
             self._logger.info("queuing reload in 30s")
-            trans.meta_data["sc_add_repo_and_install_try"]= str(retry+1)
-            sourcepart = trans.meta_data["sc_add_repo_and_install_sources_list"]
+            trans.meta_data["sc_add_repo_and_install_try"] = str(retry + 1)
+            sourcepart = trans.meta_data[
+                "sc_add_repo_and_install_sources_list"]
             GObject.timeout_add_seconds(30, self._reload_for_commercial_repo,
                                      app, trans.meta_data, sourcepart)
 
     # internal helpers
     def _on_lowlevel_transactions_changed(self, watcher, current, pending):
-        # cleanup progress signal (to be sure to not leave dbus matchers around)
+        # cleanup progress signal (to be sure to not leave dbus
+        # matchers around)
         if self._progress_signal:
             GObject.source_remove(self._progress_signal)
             self._progress_signal = None
@@ -683,7 +713,8 @@
         if current:
             try:
                 trans = client.get_transaction(current)
-                self._progress_signal = trans.connect("progress-changed", self._on_progress_changed)
+                self._progress_signal = trans.connect("progress-changed",
+                    self._on_progress_changed)
             except dbus.DBusException:
                 pass
 
@@ -693,12 +724,14 @@
             if not tid:
                 continue
             try:
-                trans = client.get_transaction(tid, error_handler=lambda x: True)
+                trans = client.get_transaction(tid,
+                    error_handler=lambda x: True)
             except dbus.DBusException:
                 continue
             trans_progress = TransactionProgress(trans)
             try:
-                self.pending_transactions[trans_progress.pkgname] = trans_progress
+                self.pending_transactions[trans_progress.pkgname] = \
+                    trans_progress
             except KeyError:
                 # if its not a transaction from us (sc_pkgname) still
                 # add it with the tid as key to get accurate results
@@ -709,19 +742,20 @@
         self.inject_fake_transactions_and_emit_changed_signal()
 
     def inject_fake_transactions_and_emit_changed_signal(self):
-        """ 
+        """
         ensures that the fake transactions are considered and emits
         transactions-changed signal with the right pending transactions
         """
         # inject a bunch FakePurchaseTransaction into the transations dict
         for pkgname in self.pending_purchases:
-            self.pending_transactions[pkgname] = self.pending_purchases[pkgname]
+            self.pending_transactions[pkgname] = \
+                self.pending_purchases[pkgname]
         # and emit the signal
         self.emit("transactions-changed", self.pending_transactions)
 
     def _on_progress_changed(self, trans, progress):
-        """ 
-        internal helper that gets called on our package transaction progress 
+        """
+        internal helper that gets called on our package transaction progress
         (only showing pkg progress currently)
         """
         try:
@@ -741,7 +775,8 @@
             return
         # hide any private ppa details in the error message since it may
         # appear in the logs for LP bugs and potentially in screenshots as well
-        cleaned_error_details = obfuscate_private_ppa_details(trans.error_details)
+        cleaned_error_details = obfuscate_private_ppa_details(
+            trans.error_details)
         msg = utf8("%s: %s\n%s\n\n%s") % (
               utf8(_("Error")),
               utf8(enums.get_error_string_from_enum(trans.error_code)),
@@ -750,20 +785,23 @@
         self._logger.error("error in _on_trans_finished '%s'" % msg)
         # show dialog to the user and exit (no need to reopen the cache)
         if not trans.error_code:
-            # sometimes aptdaemon doesn't return a value for error_code when the network
-            # connection has become unavailable; in that case, we will assume it's a
-            # failure during a package download because that is the only case where we
-            # see this happening - this avoids display of an empty error dialog and
-            # correctly prompts the user to check their network connection (see LP: #747172)
-            # FIXME: fix aptdaemon to return a valid error_code under all conditions
+            # sometimes aptdaemon doesn't return a value for error_code
+            # when the network connection has become unavailable; in
+            # that case, we will assume it's a failure during a package
+            # download because that is the only case where we see this
+            # happening - this avoids display of an empty error dialog
+            # and correctly prompts the user to check their network
+            # connection (see LP: #747172)
+            # FIXME: fix aptdaemon to return a valid error_code under
+            # all conditions
             trans.error_code = enums.ERROR_PACKAGE_DOWNLOAD_FAILED
         # show dialog to the user and exit (no need to reopen
         # the cache)
         res = self.ui.error(None,
-                            utf8(enums.get_error_string_from_enum(trans.error_code)),
-                            utf8(enums.get_error_description_from_enum(trans.error_code)),
-                            utf8(cleaned_error_details),
-                            utf8(alternative_action))
+            utf8(enums.get_error_string_from_enum(trans.error_code)),
+            utf8(enums.get_error_description_from_enum(trans.error_code)),
+            utf8(cleaned_error_details),
+            utf8(alternative_action))
         return res
 
     def _get_app_and_icon_and_deb_from_trans(self, trans):
@@ -794,7 +832,7 @@
                         self.install(app, iconname, filename, [], [],
                                      metadata=meta_copy, force=True)
                         return
-                # on unauthenticated errors, try a "repair" using the 
+                # on unauthenticated errors, try a "repair" using the
                 # reload functionatlity
                 elif trans.error.code == enums.ERROR_PACKAGE_UNAUTHENTICATED:
                     action = _("Repair")
@@ -808,7 +846,8 @@
                                      metadata=meta_copy)
                         return
 
-            elif not "sc_add_repo_and_install_ignore_errors" in trans.meta_data:
+            elif (not "sc_add_repo_and_install_ignore_errors" in
+                trans.meta_data):
                 self._show_transaction_failed_dialog(trans, enum)
 
         # send finished signal, use "" here instead of None, because
@@ -827,7 +866,8 @@
             self.emit("reload-finished", trans, enum != enums.EXIT_FAILED)
         # send appropriate signals
         self.inject_fake_transactions_and_emit_changed_signal()
-        self.emit("transaction-finished", TransactionFinishedResult(trans, enum != enums.EXIT_FAILED))
+        self.emit("transaction-finished", TransactionFinishedResult(trans,
+            enum != enums.EXIT_FAILED))
 
     @inline_callbacks
     def _config_file_conflict(self, transaction, old, new):
@@ -871,7 +911,8 @@
                 # setup debconf only if we have a pkg
                 yield trans.set_debconf_frontend("gnome", defer=True)
                 trans.set_remove_obsoleted_depends(True, defer=True)
-                self._progress_signal = trans.connect("progress-changed", self._on_progress_changed)
+                self._progress_signal = trans.connect("progress-changed",
+                    self._on_progress_changed)
                 self.pending_transactions[pkgname] = TransactionProgress(trans)
             # generic metadata
             if metadata:
@@ -919,4 +960,3 @@
     backend.enable_component("multiverse")
     from gi.repository import Gtk
     Gtk.main()
-

=== modified file 'softwarecenter/backend/installbackend_impl/packagekit_enums.py'
--- softwarecenter/backend/installbackend_impl/packagekit_enums.py	2011-12-16 12:50:18 +0000
+++ softwarecenter/backend/installbackend_impl/packagekit_enums.py	2012-03-16 20:20:25 +0000
@@ -18,9 +18,11 @@
 
 from gi.repository import PackageKitGlib as packagekit
 
+
 # this requires packagekit 0.7.2 or better
-def status_enum_to_localised_text (status):
+def status_enum_to_localised_text(status):
     return packagekit.info_enum_to_localised_present(status)
 
-def role_enum_to_localised_present (role):
+
+def role_enum_to_localised_present(role):
     return packagekit.role_enum_to_localised_present(role)

=== modified file 'softwarecenter/backend/installbackend_impl/packagekitd.py'
--- softwarecenter/backend/installbackend_impl/packagekitd.py	2012-02-07 16:56:40 +0000
+++ softwarecenter/backend/installbackend_impl/packagekitd.py	2012-03-16 20:20:25 +0000
@@ -24,10 +24,12 @@
 from gi.repository import PackageKitGlib as packagekit
 
 from softwarecenter.enums import TransactionTypes
-from softwarecenter.backend.transactionswatcher import (BaseTransactionsWatcher,
-                                                        BaseTransaction,
-                                                        TransactionFinishedResult,
-                                                        TransactionProgress)
+from softwarecenter.backend.transactionswatcher import (
+    BaseTransactionsWatcher,
+    BaseTransaction,
+    TransactionFinishedResult,
+    TransactionProgress
+)
 from softwarecenter.backend.installbackend import InstallBackend
 from softwarecenter.backend.installbackend_impl import packagekit_enums
 
@@ -36,9 +38,10 @@
 
 LOG = logging.getLogger("softwarecenter.backend.packagekit")
 
+
 class PackagekitTransaction(BaseTransaction):
     _meta_data = {}
-    
+
     def __init__(self, trans):
         """ trans -- a PkProgress object """
         GObject.GObject.__init__(self)
@@ -50,18 +53,26 @@
         because PK DBus exposes only a generic Changed, without
         specifying the property changed
         """
-        self._trans.connect('notify::role', self._emit, 'role-changed', 'role')
-        self._trans.connect('notify::status', self._emit, 'status-changed', 'status')
-        self._trans.connect('notify::percentage', self._emit, 'progress-changed', 'percentage')
-        #self._trans.connect('notify::subpercentage', self._emit, 'progress-changed', 'subpercentage') # SC UI does not support subprogress
-        self._trans.connect('notify::percentage', self._emit, 'progress-changed', 'percentage')
-        self._trans.connect('notify::allow-cancel', self._emit, 'cancellable-changed', 'allow-cancel')
+        self._trans.connect('notify::role', self._emit,
+            'role-changed', 'role')
+        self._trans.connect('notify::status', self._emit,
+            'status-changed', 'status')
+        self._trans.connect('notify::percentage', self._emit,
+            'progress-changed', 'percentage')
+        # SC UI does not support subprogress:
+        #self._trans.connect('notify::subpercentage', self._emit,
+        #    'progress-changed', 'subpercentage')
+        self._trans.connect('notify::percentage', self._emit,
+            'progress-changed', 'percentage')
+        self._trans.connect('notify::allow-cancel', self._emit,
+            'cancellable-changed', 'allow-cancel')
 
         # connect the delete:
-        proxy = dbus.SystemBus().get_object('org.freedesktop.PackageKit', self.tid)
+        proxy = dbus.SystemBus().get_object('org.freedesktop.PackageKit',
+            self.tid)
         trans = dbus.Interface(proxy, 'org.freedesktop.PackageKit.Transaction')
         trans.connect_to_signal("Destroy", self._remove)
-        
+
     def _emit(self, *args):
         prop, what = args[-1], args[-2]
         self.emit(what, self._trans.get_property(prop))
@@ -69,25 +80,31 @@
     @property
     def tid(self):
         return self._trans.get_property('transaction-id')
+
     @property
     def status_details(self):
-        return self.get_status_description() # FIXME
+        return self.get_status_description()  # FIXME
+
     @property
     def meta_data(self):
         return self._meta_data
+
     @property
     def cancellable(self):
         return self._trans.get_property('allow-cancel')
+
     @property
     def progress(self):
         return self._trans.get_property('percentage')
 
     def get_role_description(self, role=None):
         role = role if role is not None else self._trans.get_property('role')
-        return self.meta_data.get('sc_appname', packagekit_enums.role_enum_to_localised_present(role))
+        return self.meta_data.get('sc_appname',
+            packagekit_enums.role_enum_to_localised_present(role))
 
     def get_status_description(self, status=None):
-        status = status if status is not None else self._trans.get_property('status')
+        if status is None:
+            status = self._trans.get_property('status')
 
         return packagekit_enums.status_enum_to_localised_text(status)
 
@@ -107,7 +124,8 @@
                status <= packagekit.StatusEnum.DOWNLOAD_UPDATEINFO)
 
     def cancel(self):
-        proxy = dbus.SystemBus().get_object('org.freedesktop.PackageKit', self.tid)
+        proxy = dbus.SystemBus().get_object('org.freedesktop.PackageKit',
+            self.tid)
         trans = dbus.Interface(proxy, 'org.freedesktop.PackageKit.Transaction')
         trans.Cancel()
 
@@ -120,6 +138,7 @@
             del PackagekitTransactionsWatcher._tlist[self.tid]
             LOG.debug("Delete transaction %s" % self.tid)
 
+
 class PackagekitTransactionsWatcher(BaseTransactionsWatcher):
     _tlist = {}
 
@@ -128,9 +147,10 @@
         self.client = packagekit.Client()
 
         bus = dbus.SystemBus()
-        proxy = bus.get_object('org.freedesktop.PackageKit', '/org/freedesktop/PackageKit')
+        proxy = bus.get_object('org.freedesktop.PackageKit',
+            '/org/freedesktop/PackageKit')
         daemon = dbus.Interface(proxy, 'org.freedesktop.PackageKit')
-        daemon.connect_to_signal("TransactionListChanged", 
+        daemon.connect_to_signal("TransactionListChanged",
                                      self._on_transactions_changed)
         queued = daemon.GetTransactionList()
         self._on_transactions_changed(queued)
@@ -161,29 +181,30 @@
             return trans
         return PackagekitTransactionsWatcher._tlist[tid]
 
+
 class PackagekitBackend(GObject.GObject, InstallBackend):
-    
-    __gsignals__ = {'transaction-started':(GObject.SIGNAL_RUN_FIRST,
+
+    __gsignals__ = {'transaction-started': (GObject.SIGNAL_RUN_FIRST,
                                             GObject.TYPE_NONE,
-                                            (str,str,str,str)),
+                                            (str, str, str, str)),
                     # emits a TransactionFinished object
-                    'transaction-finished':(GObject.SIGNAL_RUN_FIRST,
-                                            GObject.TYPE_NONE,
-                                            (GObject.TYPE_PYOBJECT, )),
-                    'transaction-stopped':(GObject.SIGNAL_RUN_FIRST,
+                    'transaction-finished': (GObject.SIGNAL_RUN_FIRST,
+                                             GObject.TYPE_NONE,
+                                             (GObject.TYPE_PYOBJECT, )),
+                    'transaction-stopped': (GObject.SIGNAL_RUN_FIRST,
                                             GObject.TYPE_NONE,
                                             (GObject.TYPE_PYOBJECT,)),
-                    'transactions-changed':(GObject.SIGNAL_RUN_FIRST,
-                                            GObject.TYPE_NONE,
-                                            (GObject.TYPE_PYOBJECT, )),
-                    'transaction-progress-changed':(GObject.SIGNAL_RUN_FIRST,
-                                                    GObject.TYPE_NONE,
-                                                    (str,int,)),
+                    'transactions-changed': (GObject.SIGNAL_RUN_FIRST,
+                                             GObject.TYPE_NONE,
+                                             (GObject.TYPE_PYOBJECT, )),
+                    'transaction-progress-changed': (GObject.SIGNAL_RUN_FIRST,
+                                                     GObject.TYPE_NONE,
+                                                     (str, int,)),
                     # the number/names of the available channels changed
                     # FIXME: not emitted.
-                    'channels-changed':(GObject.SIGNAL_RUN_FIRST,
-                                        GObject.TYPE_NONE,
-                                        (bool,)),
+                    'channels-changed': (GObject.SIGNAL_RUN_FIRST,
+                                         GObject.TYPE_NONE,
+                                         (bool,)),
                     }
 
     def __init__(self):
@@ -192,7 +213,7 @@
 
         # transaction details for setting as meta
         self.new_pkgname, self.new_appname, self.new_iconname = '', '', ''
-        
+
         # this is public exposed
         self.pending_transactions = {}
 
@@ -202,11 +223,12 @@
 
         self._transactions_watcher = PackagekitTransactionsWatcher()
         self._transactions_watcher.connect('lowlevel-transactions-changed',
-                                self._on_lowlevel_transactions_changed)        
+                                self._on_lowlevel_transactions_changed)
 
     def upgrade(self, pkgname, appname, iconname, addons_install=[],
                 addons_remove=[], metadata=None):
-        pass # FIXME implement it
+        pass  # FIXME implement it
+
     def remove(self, app, iconname, addons_install=[],
                 addons_remove=[], metadata=None):
         self.remove_multiple((app,), (iconname,),
@@ -220,26 +242,29 @@
         appnames = [app.appname for app in apps]
 
         # keep track of pkg, app and icon for setting them as meta
-        self.new_pkgname, self.new_appname, self.new_iconname = pkgnames[0], appnames[0], iconnames[0]
+        self.new_pkgname = pkgnames[0]
+        self.new_appname = appnames[0]
+        self.new_iconname = iconnames[0]
 
         # temporary hack
         pkgnames = self._fix_pkgnames(pkgnames)
 
         self.client.remove_packages_async(pkgnames,
-                    False, # allow deps
-                    False, # autoremove
-                    None, # cancellable
+                    False,  # allow deps
+                    False,  # autoremove
+                    None,  # cancellable
                     self._on_progress_changed,
-                    None, # progress data
-                    self._on_remove_ready, # callback ready
-                    None # callback data
+                    None,  # progress data
+                    self._on_remove_ready,  # callback ready
+                    None  # callback data
         )
-        self.emit("transaction-started", pkgnames[0], appnames[0], 0, TransactionTypes.REMOVE)
+        self.emit("transaction-started", pkgnames[0], appnames[0], 0,
+            TransactionTypes.REMOVE)
 
     def install(self, app, iconname, filename=None,
                 addons_install=[], addons_remove=[], metadata=None):
         if filename is not None:
-            LOG.error("Filename not implemented") # FIXME
+            LOG.error("Filename not implemented")  # FIXME
         else:
             self.install_multiple((app,), (iconname,),
                  addons_install, addons_remove, metadata
@@ -252,7 +277,9 @@
         appnames = [app.appname for app in apps]
 
         # keep track of pkg, app and icon for setting them as meta
-        self.new_pkgname, self.new_appname, self.new_iconname = pkgnames[0], appnames[0], iconnames[0]
+        self.new_pkgname = pkgnames[0]
+        self.new_appname = appnames[0]
+        self.new_iconname = iconnames[0]
 
         # temporary hack
         pkgnames = self._fix_pkgnames(pkgnames)
@@ -263,19 +290,21 @@
         # PackageKit from installing untrusted packages
         # (in general, all enabled repos should have GPG signatures,
         # which is enough for being marked "trusted", but still)
-        self.client.install_packages_async(True, # only trusted
+        self.client.install_packages_async(True,  # only trusted
                     pkgnames,
-                    None, # cancellable
+                    None,  # cancellable
                     self._on_progress_changed,
-                    None, # progress data
-                    self._on_install_ready, # GAsyncReadyCallback
+                    None,  # progress data
+                    self._on_install_ready,  # GAsyncReadyCallback
                     None  # ready data
         )
-        self.emit("transaction-started", pkgnames[0], appnames[0], 0, TransactionTypes.INSTALL)
+        self.emit("transaction-started", pkgnames[0], appnames[0], 0,
+            TransactionTypes.INSTALL)
 
     def apply_changes(self, pkgname, appname, iconname,
         addons_install=[], addons_remove=[], metadata=None):
         pass
+
     def reload(self, sources_list=None, metadata=None):
         """ reload package list """
         pass
@@ -313,15 +342,19 @@
             if self.new_pkgname not in self.pending_transactions:
                 self.pending_transactions[self.new_pkgname] = trans
 
-        #LOG.debug("Progress update %s %s %s %s" % (status, ptype, progress.get_property('transaction-id'),progress.get_property('status')))
+        # LOG.debug("Progress update %s %s %s %s" %
+        #     (status, ptype, progress.get_property('transaction-id'),
+        #     progress.get_property('status')))
 
         if status == packagekit.StatusEnum.FINISHED:
             LOG.debug("Transaction finished %s" % tid)
-            self.emit("transaction-finished", TransactionFinishedResult(trans, True))
+            self.emit("transaction-finished",
+                TransactionFinishedResult(trans, True))
 
         if status == packagekit.StatusEnum.CANCEL:
             LOG.debug("Transaction canceled %s" % tid)
-            self.emit("transaction-stopped", TransactionFinishedResult(trans, True))
+            self.emit("transaction-stopped",
+                TransactionFinishedResult(trans, True))
 
         if ptype == packagekit.ProgressType.PACKAGE:
             # this should be done better
@@ -348,7 +381,8 @@
             trans = self._transactions_watcher.get_transaction(tid)
             trans_progress = TransactionProgress(trans)
             try:
-                self.pending_transactions[trans_progress.pkgname] = trans_progress
+                self.pending_transactions[
+                    trans_progress.pkgname] = trans_progress
             except:
                 self.pending_transactions[trans.tid] = trans_progress
 
@@ -375,7 +409,7 @@
 
     loop = dbus.mainloop.glib.DBusGMainLoop()
     dbus.set_default_main_loop(loop)
-    
+
     backend = PackagekitBackend()
     pkginfo = get_pkg_info()
     if pkginfo[package].is_installed:
@@ -387,4 +421,3 @@
     from gi.repository import Gtk
     Gtk.main()
     #print backend._fix_pkgnames(('cheese',))
-

=== modified file 'softwarecenter/backend/piston/rnrclient.py'
--- softwarecenter/backend/piston/rnrclient.py	2011-10-26 10:25:49 +0000
+++ softwarecenter/backend/piston/rnrclient.py	2012-03-16 20:20:25 +0000
@@ -31,15 +31,18 @@
 # get the server to use
 from softwarecenter.distro import get_distro
 distro = get_distro()
-SERVER_ROOT=distro.REVIEWS_SERVER
+SERVER_ROOT = distro.REVIEWS_SERVER
 
 try:
     if "SOFTWARE_CENTER_FAKE_REVIEW_API" in os.environ:
-        from softwarecenter.backend.piston.rnrclient_fake import RatingsAndReviewsAPI
+        from softwarecenter.backend.piston.rnrclient_fake import (
+            RatingsAndReviewsAPI
+        )
         RatingsAndReviewsAPI.default_service_root = SERVER_ROOT
         import rnrclient_fake
         rnrclient_fake
-        LOG.warn("using FAKE review api, data returned will be dummy data only")
+        LOG.warn("using FAKE review api, data returned will be dummy "
+            "data only")
     else:
         # patch default_service_root
         from rnrclient_pristine import RatingsAndReviewsAPI
@@ -68,22 +71,24 @@
     # dump all reviews
     for stat in rnr.review_stats():
         print("stats for (pkg='%s', app: '%s'):  avg=%s total=%s" % (
-            stat.package_name, stat.app_name, stat.ratings_average, stat.ratings_total))
+            stat.package_name, stat.app_name, stat.ratings_average,
+                stat.ratings_total))
         reviews = rnr.get_reviews(
             language="any", origin="ubuntu", distroseries="natty",
             packagename=stat.package_name,
             appname=urllib.quote_plus(stat.app_name.encode("utf-8")))
         for review in reviews:
-            print("rating: %s  user=%s" % (review.rating, review.reviewer_username))
+            print("rating: %s  user=%s" % (review.rating,
+                review.reviewer_username))
             print(review.summary)
             print(review.review_text)
             print("\n")
-        
+
     # get individual ones
-    reviews = rnr.get_reviews(language="en",origin="ubuntu",distroseries="maverick",
-                             packagename="unace", appname="ACE")
+    reviews = rnr.get_reviews(language="en", origin="ubuntu",
+        distroseries="maverick", packagename="unace", appname="ACE")
     print(reviews)
-    print(rnr.get_reviews(language="en",origin="ubuntu",distroseries="natty",
+    print(rnr.get_reviews(language="en", origin="ubuntu", distroseries="natty",
                           packagename="aclock.app"))
     print(rnr.get_reviews(language="en", origin="ubuntu", distroseries="natty",
                           packagename="unace", appname="ACE"))

=== modified file 'softwarecenter/backend/piston/rnrclient_fake.py'
--- softwarecenter/backend/piston/rnrclient_fake.py	2011-08-15 11:55:13 +0000
+++ softwarecenter/backend/piston/rnrclient_fake.py	2012-03-16 20:20:25 +0000
@@ -17,36 +17,40 @@
 AUTHENTICATED_API_SCHEME = 'https'
 
 from rnrclient_pristine import ReviewRequest, ReviewsStats, ReviewDetails
-from softwarecenter.backend.fake_review_settings import FakeReviewSettings, network_delay
+from softwarecenter.backend.fake_review_settings import (
+    FakeReviewSettings,
+    network_delay,
+)
 import json
 import random
 import time
 
 
 class RatingsAndReviewsAPI(PistonAPI):
-    """A fake client pretending to be RAtingsAndReviewsAPI from rnrclient_pristine.
-       Uses settings from test.fake_review_settings.FakeReviewSettings
-       to provide predictable responses to methods that try to use the 
-       RatingsAndReviewsAPI for testing purposes (i.e. without network activity).
-       To use this, instead of importing from rnrclient_pristine, you can import
-       from rnrclient_fake instead.
+    """A fake client pretending to be RAtingsAndReviewsAPI from
+       rnrclient_pristine.  Uses settings from
+       test.fake_review_settings.FakeReviewSettings
+       to provide predictable responses to methods that try to use the
+       RatingsAndReviewsAPI for testing purposes (i.e. without network
+       activity).
+       To use this, instead of importing from rnrclient_pristine, you can
+       import from rnrclient_fake instead.
     """
-    
+
     default_service_root = 'http://localhost:8000/reviews/api/1.0'
     default_content_type = 'application/x-www-form-urlencoded'
     _exception_msg = 'Fake RatingsAndReviewsAPI raising fake exception'
-    _PACKAGE_NAMES = ['armagetronad', 'compizconfig-settings-manager', 'file-roller', 
-                     'aisleriot', 'p7zip-full', 'compiz-core', 'banshee', 
-                     'gconf-editor', 'nanny', '3depict', 'apturl', 'jockey-gtk', 
-                     'alex4', 'bzr-explorer', 'aqualung']
-    _USERS = ["Joe Doll", "John Foo", "Cat Lala", "Foo Grumpf", 
+    _PACKAGE_NAMES = ['armagetronad', 'compizconfig-settings-manager',
+                      'file-roller', 'aisleriot', 'p7zip-full', 'compiz-core',
+                      'banshee', 'gconf-editor', 'nanny', '3depict', 'apturl',
+                      'jockey-gtk', 'alex4', 'bzr-explorer', 'aqualung']
+    _USERS = ["Joe Doll", "John Foo", "Cat Lala", "Foo Grumpf",
              "Bar Tender", "Baz Lightyear"]
     _SUMMARIES = ["Cool", "Medium", "Bad", "Too difficult"]
-    _TEXT = ["Review text number 1", "Review text number 2", 
+    _TEXT = ["Review text number 1", "Review text number 2",
             "Review text number 3", "Review text number 4"]
     _fake_settings = FakeReviewSettings()
 
-
     @returns_json
     @network_delay
     def server_status(self):
@@ -54,32 +58,31 @@
             raise APIError(self._exception_msg)
         return json.dumps('ok')
 
-
     @validate_pattern('origin', r'[0-9a-z+-.:/]+', required=False)
     @validate_pattern('distroseries', r'\w+', required=False)
     @validate('days', int, required=False)
     @returns_list_of(ReviewsStats)
     @network_delay
     def review_stats(self, origin='any', distroseries='any', days=None,
-        valid_days=(1,3,7)):
+        valid_days=(1, 3, 7)):
         if self._fake_settings.get_setting('review_stats_error'):
             raise APIError(self._exception_msg)
-            
+
         if self._fake_settings.get_setting('packages_returned') > 15:
             quantity = 15
         else:
             quantity = self._fake_settings.get_setting('packages_returned')
-            
+
         stats = []
-    
-        for i in range (0, quantity):
-            s = {'app_name':'', 
-                 'package_name':self._PACKAGE_NAMES[i], 
-                 'ratings_total': str(random.randrange(1,200)),
-                 'ratings_average': str(random.randrange(0,5))
+
+        for i in range(0, quantity):
+            s = {'app_name': '',
+                 'package_name': self._PACKAGE_NAMES[i],
+                 'ratings_total': str(random.randrange(1, 200)),
+                 'ratings_average': str(random.randrange(0, 5))
             }
             stats.append(s)
-            
+
         return json.dumps(stats)
 
     @validate_pattern('language', r'\w+', required=False)
@@ -94,7 +97,7 @@
     @network_delay
     def get_reviews(self, packagename, language='any', origin='any',
         distroseries='any', version='any', appname='', page=1, sort='helpful'):
-        
+
         # work out how many reviews to return for pagination
         if page <= self._fake_settings.get_setting('review_pages'):
             num_reviews = 10
@@ -102,10 +105,10 @@
             num_reviews = self._fake_settings.get_setting('reviews_returned')
         else:
             num_reviews = 0
-        
+
         if self._fake_settings.get_setting('get_reviews_error'):
             raise APIError(self._exception_msg)
-        
+
         reviews = self._make_fake_reviews(packagename, num_reviews)
         return json.dumps(reviews)
 
@@ -124,9 +127,11 @@
     def submit_review(self, review):
         if self._fake_settings.get_setting('submit_review_error'):
             raise APIError(self._exception_msg)
-        
-        user = self._fake_settings.get_setting('reviewer_username') or random.choice(self._USERS)
-        review_id = self._fake_settings.get_setting('submit_review_id') or random.randint(1,10000)
+
+        user = self._fake_settings.get_setting(
+            'reviewer_username') or random.choice(self._USERS)
+        review_id = self._fake_settings.get_setting(
+            'submit_review_id') or random.randint(1, 10000)
         r = {
                 "origin": review.origin,
                 "rating": review.rating,
@@ -156,13 +161,15 @@
     def flag_review(self, review_id, reason, text):
         if self._fake_settings.get_setting('flag_review_error'):
             raise APIError(self._exception_msg)
-    
-        mod_id = random.randint(1,500)
-        pkg = self._fake_settings.get_setting('flag_package_name') or random.choice(self._PACKAGE_NAMES)
-        username = self._fake_settings.get_setting('flagger_username') or random.choice(self._USERS)
+
+        mod_id = random.randint(1, 500)
+        pkg = self._fake_settings.get_setting(
+            'flag_package_name') or random.choice(self._PACKAGE_NAMES)
+        username = self._fake_settings.get_setting(
+            'flagger_username') or random.choice(self._USERS)
 
         f = {
-            "user_id": random.randint(1,500),
+            "user_id": random.randint(1, 500),
             "description": text,
             "review_moderation_id": mod_id,
             "_user_cache": self._make_user_cache(username),
@@ -170,7 +177,7 @@
             "_review_moderation_cache": {
                 "status": 0,
                 "review_id": review_id,
-                "_review_cache": self._make_fake_reviews(packagename=pkg, 
+                "_review_cache": self._make_fake_reviews(packagename=pkg,
                                                          single_id=review_id),
                 "moderation_text": text,
                 "date_moderated": None,
@@ -191,7 +198,8 @@
     def submit_usefulness(self, review_id, useful):
         if self._fake_settings.get_setting('submit_usefulness_error'):
             raise APIError(self._exception_msg)
-        return json.dumps(self._fake_settings.get_setting('usefulness_response_string'))
+        return json.dumps(self._fake_settings.get_setting(
+            'usefulness_response_string'))
 
     @validate('review_id', int, required=False)
     @validate_pattern('username', r'[^\n]+', required=False)
@@ -200,24 +208,24 @@
     def get_usefulness(self, review_id=None, username=None):
         if not username and not review_id:
             return None
-        
+
         if self._fake_settings.get_setting('get_usefulness_error'):
             raise APIError(self._exception_msg)
-        
+
         #just return a single fake item if the review_id was supplied
         if review_id:
             if username:
                 response_user = username
             else:
                 response_user = random.choice(self._USERS)
-                
+
             response = {
-                'username':response_user,
-                'useful':random.choice(['True','False']),
-                'review_id':review_id
+                'username': response_user,
+                'useful': random.choice(['True', 'False']),
+                'review_id': review_id
                 }
             return json.dumps([response])
-            
+
         #set up review ids to honour requested and also add randoms
         quantity = self._fake_settings.get_setting('votes_returned')
         id_list = self._fake_settings.get_setting('required_review_ids')
@@ -228,23 +236,23 @@
             rand_id_start = 0
         else:
             rand_id_start = max(id_list)
-        
+
         votes = []
-            
+
         for i in range(0, quantity):
             #assign review ids requested if any still exist
             try:
                 id = id_list[i]
             except IndexError:
-                id = random.randint(rand_id_start,10000)
-                
+                id = random.randint(rand_id_start, 10000)
+
             u = {
-                 'username': username, 
-                 'useful': random.choice(['True','False']), 
-                 'review_id' : id
+                 'username': username,
+                 'useful': random.choice(['True', 'False']),
+                 'review_id': id
                 }
             votes.append(u)
-        
+
         return json.dumps(votes)
 
     @validate('review_id', int)
@@ -261,29 +269,28 @@
     def modify_review(self, review_id, rating, summary, review_text):
         """Modify an existing review"""
         return json.dumps(self._make_fake_reviews()[0])
-        
-        
-    def _make_fake_reviews(self, packagename='compiz-core', 
+
+    def _make_fake_reviews(self, packagename='compiz-core',
                            quantity=1, single_id=None):
         """Make and return a requested quantity of fake reviews"""
-        
+
         reviews = []
-        
+
         for i in range(0, quantity):
             if quantity == 1 and single_id:
                 id = single_id
             else:
-                id = i*3
-                
+                id = i * 3
+
             r = {
                         "origin": "ubuntu",
-                        "rating": random.randint(1,5),
+                        "rating": random.randint(1, 5),
                         "hide": False,
                         "app_name": "",
                         "language": "en",
                         "reviewer_username": random.choice(self._USERS),
-                        "usefulness_total": random.randint(3,6),
-                        "usefulness_favorable": random.randint(1,3),
+                        "usefulness_total": random.randint(3, 6),
+                        "usefulness_favorable": random.randint(1, 3),
                         "review_text": random.choice(self._TEXT),
                         "date_deleted": None,
                         "summary": random.choice(self._SUMMARIES),
@@ -295,13 +302,13 @@
                         "distroseries": "natty"
             }
             reviews.append(r)
-            
+
         #get_review wants a dict but get_reviews wants a list of dicts
         if single_id:
             return r
         else:
             return reviews
-    
+
     def _make_user_cache(self, username):
         return {
             "username": username,
@@ -313,7 +320,6 @@
             "is_staff": False,
             "last_login": time.strftime("%Y-%m-%d %H:%M:%S"),
             "password": "!",
-            "id": random.randint(1,500),
+            "id": random.randint(1, 500),
             "date_joined": time.strftime("%Y-%m-%d %H:%M:%S")
         }
-

=== modified file 'softwarecenter/backend/piston/rnrclient_pristine.py'
--- softwarecenter/backend/piston/rnrclient_pristine.py	2011-08-15 11:55:13 +0000
+++ softwarecenter/backend/piston/rnrclient_pristine.py	2012-03-16 20:20:25 +0000
@@ -29,6 +29,7 @@
         'rating', 'language', 'origin', 'distroseries', 'arch_tag')
     app_name = ''
 
+
 class ReviewsStats(PistonResponseObject):
     """A ratings summary for a package/app.
 
@@ -82,7 +83,7 @@
     @validate('days', int, required=False)
     @returns_list_of(ReviewsStats)
     def review_stats(self, origin='any', distroseries='any', days=None,
-        valid_days=(1,3,7)):
+        valid_days=(1, 3, 7)):
         """Fetch ratings for a particular distroseries"""
         url = 'review-stats/{0}/{1}/'.format(origin, distroseries)
         if days is not None:
@@ -115,7 +116,7 @@
             appname = quote_plus(';' + appname)
         return self._get('reviews/filter/%s/%s/%s/%s/%s%s/page/%s/%s/' % (
             language, origin, distroseries, version, packagename,
-            appname, page, sort), 
+            appname, page, sort),
             scheme=PUBLIC_API_SCHEME)
 
     @validate('review_id', int)
@@ -183,6 +184,10 @@
     @returns(ReviewDetails)
     def modify_review(self, review_id, rating, summary, review_text):
         """Modify an existing review"""
-        data = {'rating':rating, 'summary':summary, 'review_text':review_text}
+        data = {
+            'rating': rating,
+            'summary': summary,
+            'review_text': review_text
+        }
         return self._put('/reviews/modify/%s/' % review_id, data=data,
         scheme=AUTHENTICATED_API_SCHEME)

=== modified file 'softwarecenter/backend/piston/scaclient.py'
--- softwarecenter/backend/piston/scaclient.py	2012-01-03 16:48:01 +0000
+++ softwarecenter/backend/piston/scaclient.py	2012-03-16 20:20:25 +0000
@@ -14,7 +14,7 @@
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 #
 #
-# taken from lp:~canonical-ca-hackers/software-center/scaclient 
+# taken from lp:~canonical-ca-hackers/software-center/scaclient
 # and put into scaclient_pristine.py
 
 import logging
@@ -31,26 +31,27 @@
 from softwarecenter.enums import BUY_SOMETHING_HOST
 try:
     from scaclient_pristine import SoftwareCenterAgentAPI
-    SoftwareCenterAgentAPI.default_service_root = BUY_SOMETHING_HOST+"/api/2.0"
+    SoftwareCenterAgentAPI.default_service_root = \
+        BUY_SOMETHING_HOST + "/api/2.0"
 except:
     logging.exception("need python-piston-mini client")
     sys.exit(1)
 
 
-
 if __name__ == "__main__":
 
     sca = SoftwareCenterAgentAPI()
-    
+
     lang = "en"
     series = "natty"
     arch = "i386"
 
     available = sca.available_apps(lang=lang, series=series, arch=arch)
     print(available)
-    
-    available_for_qa = sca.available_apps_qa(lang=lang, series=series, arch=arch)
+
+    available_for_qa = sca.available_apps_qa(lang=lang, series=series,
+        arch=arch)
     print(available_for_qa)
-    
+
     for_me = sca.subscriptions_for_me()
     print(for_me)

=== modified file 'softwarecenter/backend/piston/scaclient_pristine.py'
--- softwarecenter/backend/piston/scaclient_pristine.py	2012-01-03 16:03:59 +0000
+++ softwarecenter/backend/piston/scaclient_pristine.py	2012-03-16 20:20:25 +0000
@@ -8,6 +8,7 @@
 PUBLIC_API_SCHEME = 'http'
 AUTHENTICATED_API_SCHEME = 'https'
 
+
 class SoftwareCenterAgentAPI(PistonAPI):
     default_service_root = 'http://localhost:8000/api/2.0'
 

=== modified file 'softwarecenter/backend/piston/sreclient_pristine.py'
--- softwarecenter/backend/piston/sreclient_pristine.py	2012-02-29 20:56:24 +0000
+++ softwarecenter/backend/piston/sreclient_pristine.py	2012-03-16 20:20:25 +0000
@@ -11,6 +11,7 @@
 PUBLIC_API_SCHEME = 'http'
 AUTHENTICATED_API_SCHEME = 'https'
 
+
 class SoftwareCenterRecommenderAPI(PistonAPI):
     default_service_root = 'http://localhost:8000/api/1.0'
 

=== modified file 'softwarecenter/backend/piston/sso_helper.py'
--- softwarecenter/backend/piston/sso_helper.py	2012-01-13 16:40:48 +0000
+++ softwarecenter/backend/piston/sso_helper.py	2012-03-16 20:20:25 +0000
@@ -28,13 +28,12 @@
 from softwarecenter.utils import clear_token_from_ubuntu_sso
 
 
-
 class SSOLoginHelper(object):
     def __init__(self, xid=0):
         self.oauth = None
         self.xid = xid
         self.loop = GObject.MainLoop(GObject.main_context_default())
-    
+
     def _login_successful(self, sso_backend, oauth_result):
         self.oauth = oauth_result
         # FIXME: actually verify the token against ubuntu SSO
@@ -44,6 +43,7 @@
         def _whoami_done(sso, me):
             self._whoami = me
             self.loop.quit()
+
         def _whoami_error(sso, err):
             #print "ERRR", err
             self.loop.quit()
@@ -74,7 +74,7 @@
     def get_oauth_token_sync(self):
         self.oauth = None
         sso = get_sso_backend(
-            self.xid, 
+            self.xid,
             SOFTWARE_CENTER_NAME_KEYRING,
             _(SOFTWARE_CENTER_SSO_DESCRIPTION))
         sso.connect("login-successful", self._login_successful)

=== modified file 'test/test_pep8.py'
--- test/test_pep8.py	2012-03-16 19:16:21 +0000
+++ test/test_pep8.py	2012-03-16 20:20:25 +0000
@@ -9,6 +9,8 @@
 # Only test these two packages for now:
 import softwarecenter.backend.reviews
 import softwarecenter.backend.oneconfhandler
+import softwarecenter.backend.piston
+import softwarecenter.backend.installbackend_impl
 import softwarecenter.db
 import softwarecenter.ui
 import softwarecenter.distro
@@ -16,6 +18,8 @@
 class PackagePep8TestCase(unittest.TestCase):
     maxDiff = None
     packages = [softwarecenter.ui,
+                softwarecenter.backend.piston,
+                softwarecenter.backend.installbackend_impl,
                 softwarecenter.backend.reviews,
                 softwarecenter.backend.oneconfhandler,
                 softwarecenter.db,