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

[Anthony Lenton]

All code under softwarecenter/ now passes the pep8 test.

[Kiwinote (kiwinote)]

awesomeness :)

review: Approve

=== modified file 'softwarecenter/backend/channel.py'
--- softwarecenter/backend/channel.py	2011-12-02 14:33:49 +0000
+++ softwarecenter/backend/channel.py	2012-03-19 14:27:20 +0000
@@ -24,13 +24,14 @@
 
 from softwarecenter.distro import get_distro
 
-from softwarecenter.enums import (SortMethods, 
+from softwarecenter.enums import (SortMethods,
                                   Icons,
                                   ViewPages,
                                  )
 
 LOG = logging.getLogger(__name__)
 
+
 class ChannelsManager(object):
     def __init__(self, db, **kwargs):
         self.distro = get_distro()
@@ -52,10 +53,11 @@
     # private
     def _get_channels_from_db(self, installed_only=False):
         """
-        (internal) implements 'channels()' and 'channels_installed_only()' properties
+        (internal) implements 'channels()' and 'channels_installed_only()'
+        properties
         """
         distro_channel_origin = self.distro.get_distro_channel_name()
-        
+
         # gather the set of software channels and order them
         other_channel_list = []
         cached_origins = []
@@ -64,12 +66,13 @@
                 continue
             channel_name = channel_iter.term[3:]
             channel_origin = ""
-            
+
             # get origin information for this channel
             m = self.db.xapiandb.postlist_begin(channel_iter.term)
             doc = self.db.xapiandb.get_document(m.get_docid())
             for term_iter in doc.termlist():
-                if term_iter.term.startswith("XOO") and len(term_iter.term) > 3: 
+                if (term_iter.term.startswith("XOO") and
+                    len(term_iter.term) > 3):
                     channel_origin = term_iter.term[3:]
                     break
             LOG.debug("channel_name: %s" % channel_name)
@@ -77,7 +80,7 @@
             if channel_origin not in cached_origins:
                 other_channel_list.append((channel_name, channel_origin))
                 cached_origins.append(channel_origin)
-        
+
         dist_channel = None
         other_channels = []
         unknown_channel = []
@@ -85,26 +88,30 @@
 
         for (channel_name, channel_origin) in other_channel_list:
             if not channel_name:
-                unknown_channel.append(SoftwareChannel(channel_name,
-                                                       channel_origin,
-                                                       None,
-                                                       installed_only=installed_only))
+                unknown_channel.append(SoftwareChannel(
+                    channel_name,
+                    channel_origin,
+                    None,
+                    installed_only=installed_only))
             elif channel_origin == distro_channel_origin:
-                dist_channel = (SoftwareChannel(channel_name,
-                                                channel_origin,
-                                                None,
-                                                installed_only=installed_only))
+                dist_channel = (SoftwareChannel(
+                    channel_name,
+                    channel_origin,
+                    None,
+                    installed_only=installed_only))
             elif channel_name == "notdownloadable":
                 if installed_only:
-                    local_channel = SoftwareChannel(channel_name,
-                                                    None,
-                                                    None,
-                                                    installed_only=installed_only)
+                    local_channel = SoftwareChannel(
+                        channel_name,
+                        None,
+                        None,
+                        installed_only=installed_only)
             else:
-                other_channels.append(SoftwareChannel(channel_name,
-                                                      channel_origin,
-                                                      None,
-                                                      installed_only=installed_only))
+                other_channels.append(SoftwareChannel(
+                    channel_name,
+                    channel_origin,
+                    None,
+                    installed_only=installed_only))
 
         # set them in order
         channels = []
@@ -122,13 +129,14 @@
                 channel._channel_view_id = ViewPages.AVAILABLE
         return channels
 
+
 class SoftwareChannel(object):
     """
     class to represent a software channel
     """
-    
+
     ICON_SIZE = 24
-    
+
     def __init__(self, channel_name, channel_origin, channel_component,
                  source_entry=None, installed_only=False,
                  channel_icon=None, channel_query=None,
@@ -148,13 +156,16 @@
         # distro specific stuff
         self.distro = get_distro()
         # configure the channel
-        self._channel_display_name = self._get_display_name_for_channel(channel_name, channel_origin, channel_component)
+        self._channel_display_name = self._get_display_name_for_channel(
+            channel_name, channel_origin, channel_component)
         if channel_icon is None:
-            self._channel_icon = self._get_icon_for_channel(channel_name, channel_origin, channel_component)
+            self._channel_icon = self._get_icon_for_channel(
+                channel_name, channel_origin, channel_component)
         else:
             self._channel_icon = channel_icon
         if channel_query is None:
-            self._channel_query = self._get_channel_query_for_channel(channel_name, channel_origin, channel_component)
+            self._channel_query = self._get_channel_query_for_channel(
+                channel_name, channel_origin, channel_component)
         else:
             self._channel_query = channel_query
         # a sources.list entry attached to the channel (this is currently
@@ -162,36 +173,36 @@
         self._source_entry = source_entry
         # when the channel needs to be added to the systems sources.list
         self.needs_adding = False
-        
+
     @property
     def name(self):
         """
         return the channel name as represented in the xapian database
         """
         return self._channel_name
-       
-    @property 
+
+    @property
     def origin(self):
         """
         return the channel origin as represented in the xapian database
         """
         return self._channel_origin
-    
-    @property    
+
+    @property
     def component(self):
         """
         return the channel component as represented in the xapian database
         """
         return self._channel_component
-    
-    @property   
+
+    @property
     def display_name(self):
         """
         return the display name for the corresponding channel for use in the UI
         """
         return self._channel_display_name
-    
-    @property    
+
+    @property
     def icon(self):
         """
         return the icon that corresponds to each channel based
@@ -205,18 +216,19 @@
         return the xapian query to be used with this software channel
         """
         return self._channel_query
-    
-    @property    
+
+    @property
     def sort_mode(self):
         """
         return the sort mode for this software channel
         """
         return self._channel_sort_mode
-        
+
     # TODO:  implement __cmp__ so that sort for channels is encapsulated
     #        here as well
 
-    def _get_display_name_for_channel(self, channel_name, channel_origin, channel_component):
+    def _get_display_name_for_channel(self, channel_name, channel_origin,
+        channel_component):
         if channel_component == "partner":
             channel_display_name = _("Canonical Partners")
         elif not channel_origin:
@@ -232,8 +244,9 @@
         else:
             return channel_name
         return channel_display_name
-    
-    def _get_icon_for_channel(self, channel_name, channel_origin, channel_component):
+
+    def _get_icon_for_channel(self, channel_name, channel_origin,
+        channel_component):
         if channel_component == "partner":
             channel_icon = "partner"
         elif not channel_name:
@@ -253,16 +266,17 @@
         else:
             channel_icon = "unknown-channel"
         return channel_icon
-    
-    def _get_channel_query_for_channel(self, channel_name, channel_origin, channel_component):
-    
+
+    def _get_channel_query_for_channel(self, channel_name, channel_origin,
+        channel_component):
+
         if channel_component == "partner":
             q1 = xapian.Query("XOCpartner")
             q2 = xapian.Query("AH%s-partner" % self.distro.get_codename())
             channel_query = xapian.Query(xapian.Query.OP_OR, q1, q2)
         # show only apps when displaying the new apps archive
         elif channel_name == "Application Review Board PPA":
-            channel_query = xapian.Query(xapian.Query.OP_AND, 
+            channel_query = xapian.Query(xapian.Query.OP_AND,
                                          xapian.Query("XOL" + channel_name),
                                          xapian.Query("ATapplication"))
         elif channel_origin:
@@ -292,14 +306,14 @@
             self, channel_name, "all", None,
             installed_only=installed_only,
             channel_icon=Icons.FALLBACK)
-        return
 
     # overrides
-    def _get_display_name_for_channel(self, channel_name, channel_origin, channel_component):
+    def _get_display_name_for_channel(self, channel_name, channel_origin,
+        channel_component):
         return channel_name
 
     def _get_channel_query_for_channel(self, *args):
-        return None
+        pass
 
 
 class AllAvailableChannel(AllChannel):
@@ -313,28 +327,34 @@
     def __init__(self):
         AllChannel.__init__(self, _("All Installed"), True)
 
+
 # singleton
 channels_manager = None
+
+
 def get_channels_manager(db):
     global channels_manager
     if channels_manager is None:
         from softwarecenter.enums import USE_PACKAGEKIT_BACKEND
         if not USE_PACKAGEKIT_BACKEND:
-            from softwarecenter.backend.channel_impl.aptchannels import AptChannelsManager
+            from softwarecenter.backend.channel_impl.aptchannels import (
+                AptChannelsManager)
             channels_manager = AptChannelsManager(db)
         else:
             channels_manager = ChannelsManager(db)
     return channels_manager
 
+
 def is_channel_available(channelname):
-    from softwarecenter.backend.channel_impl.aptchannels import AptChannelsManager
+    from softwarecenter.backend.channel_impl.aptchannels import (
+        AptChannelsManager)
     return AptChannelsManager.channel_available(channelname)
 
 if __name__ == "__main__":
     distro = get_distro()
-    channel = SoftwareChannel(distro.get_distro_channel_name(), 
+    channel = SoftwareChannel(distro.get_distro_channel_name(),
                               None, None)
     print(channel)
-    channel = SoftwareChannel(distro.get_distro_channel_name(), None, "partner")
+    channel = SoftwareChannel(distro.get_distro_channel_name(), None,
+        "partner")
     print(channel)
-
 
=== modified file 'softwarecenter/backend/fake_review_settings.py'
--- softwarecenter/backend/fake_review_settings.py	2011-08-09 08:47:43 +0000
+++ softwarecenter/backend/fake_review_settings.py	2012-03-19 14:27:20 +0000
@@ -4,7 +4,8 @@
 import pickle
 from softwarecenter.paths import SOFTWARE_CENTER_CACHE_DIR
 
-# decorator to add a fake network delay if set 
+
+# decorator to add a fake network delay if set
 # in FakeReviewSettings.fake_network_delay
 def network_delay(fn):
     def slp(self, *args, **kwargs):
@@ -14,23 +15,25 @@
             time.sleep(delay)
         return fn(self, *args, **kwargs)
     return slp
-   
+
+
 class FakeReviewSettings(object):
-    '''An object that simply holds settings which are used by RatingsAndReviewsAPI
-       in the rnrclient_fake module. Using this module allows a developer to test
-       the reviews functionality without any interaction with a reviews server.
-       Each setting here provides complete control over how the 'server' will 
-       respond. Changes to these settings should be made to the class attributes
-       directly without creating an instance of this class.
-       The intended usage is for unit tests where a predictable response is 
-       required and where the application should THINK it has spoken to a 
-       server. 
-       The unit test would make changes to settings in this class before 
+    '''An object that simply holds settings which are used by
+       RatingsAndReviewsAPI in the rnrclient_fake module. Using this module
+       allows a developer to test the reviews functionality without any
+       interaction with a reviews server.  Each setting here provides complete
+       control over how the 'server' will respond. Changes to these settings
+       should be made to the class attributes directly without creating an
+       instance of this class.
+       The intended usage is for unit tests where a predictable response is
+       required and where the application should THINK it has spoken to a
+       server.
+       The unit test would make changes to settings in this class before
        running the unit test.
     '''
-    
+
     _FAKE_SETTINGS = {}
-    
+
     #general settings
     #*****************************
     #delay (in seconds) before returning from any of the fake rnr methods
@@ -41,45 +44,46 @@
     #*****************************
     #raises APIError if True
     _FAKE_SETTINGS['server_response_error'] = False
-    
+
     #review stats
     #*****************************
     #raises APIError if True
-    _FAKE_SETTINGS['review_stats_error'] = False    
-    
+    _FAKE_SETTINGS['review_stats_error'] = False
+
     #the following has no effect if review_stats_error = True
-    #determines the number of package stats (i.e. ReviewStats list size) to return
-    #max 15 packages (any number higher than 15 will still return 15)
+    #determines the number of package stats (i.e. ReviewStats list size) to
+    #return max 15 packages (any number higher than 15 will still return 15)
     _FAKE_SETTINGS['packages_returned'] = 10
-    
+
     #get reviews
     #*****************************
     #raises APIError if True
     _FAKE_SETTINGS['get_reviews_error'] = False
 
-    #number of pages of 10 reviews to return before returning the number specified
-    #in the reviews_returned value below
+    #number of pages of 10 reviews to return before returning the number
+    # specified in the reviews_returned value below
     _FAKE_SETTINGS['review_pages'] = 1
 
     #the following has no effect if get_reviews_error = True
-    #determines number of reviews to return 
+    #determines number of reviews to return
     # (Accepts 0 to n but should really be between 1 and 10)
     _FAKE_SETTINGS['reviews_returned'] = 3
-    
+
     #get review
     #*****************************
     #raises APIError if True
     _FAKE_SETTINGS['get_review_error'] = False
-    
+
     #submit review
     #*****************************
     #raises APIError if True
     _FAKE_SETTINGS['submit_review_error'] = False
-    #fake username(str) and review_id(int) to give back with a successful review
+    #fake username(str) and review_id(int) to give back with a successful
+    # review
     #leave as None to generate a random username and review_id
     _FAKE_SETTINGS['reviewer_username'] = None
     _FAKE_SETTINGS['submit_review_id'] = None
-    
+
     #flag review
     #*****************************
     #raises APIError if True
@@ -88,43 +92,43 @@
     _FAKE_SETTINGS['flagger_username'] = None
     #fake package name (str) to give back as flagged app
     _FAKE_SETTINGS['flag_package_name'] = None
-    
+
     #submit usefulness
     #*****************************
     #raises APIError if True
     _FAKE_SETTINGS['submit_usefulness_error'] = False
-    
+
     #the following has no effect if submit_usefulness_error = True
     #which string to pretend the server returned
     #choices are "Created", "Updated", "Not modified"
     _FAKE_SETTINGS['usefulness_response_string'] = "Created"
-    
+
     #get usefulness
     #*****************************
     #raises APIError if True
     _FAKE_SETTINGS['get_usefulness_error'] = False
-    
+
     #the following has no effect if get_usefulness_error = True
     #how many usefulness votes to return
     _FAKE_SETTINGS['votes_returned'] = 5
-    
-    #pre-configured review ids to return in the result 
+
+    #pre-configured review ids to return in the result
     #if you don't complete this or enter less review ids than votes_returned
     #above, it will be random
-    _FAKE_SETTINGS['required_review_ids'] = [3,6,15]
-    
+    _FAKE_SETTINGS['required_review_ids'] = [3, 6, 15]
+
     #THE FOLLOWING SETTINGS RELATE TO LOGIN SSO FUNCTIONALITY
     # LoginBackendDbusSSO
     # login()
     #***********************
-    # what to fake the login response as 
+    # what to fake the login response as
     # choices (strings): "successful", "failed", "denied"
     _FAKE_SETTINGS['login_response'] = "successful"
-    
+
     # UbuntuSSOAPI
     # whoami()
     #***********************
-    # what to fake whoami response as 
+    # what to fake whoami response as
     # choices (strings): "whoami", "error"
     _FAKE_SETTINGS['whoami_response'] = "whoami"
     #this only has effect if whoami_response = 'whoami'
@@ -132,65 +136,65 @@
     #expects a string or None (for a random username)
     _FAKE_SETTINGS['whoami_username'] = None
 
-
     def __init__(self, defaults=False):
-        '''Initialises the object and loads the settings into the _FAKE_SETTINGS
-           dict.. If defaults is passed as True any existing settings in the cache 
-           file are ignored and the cache file is overwritten with the defaults 
-           set in the class. This is useful if you don't want previously used 
-           settings from the cache file being used again'''
+        '''Initialises the object and loads the settings into the
+           _FAKE_SETTINGS dict.. If defaults is passed as True any existing
+           settings in the cache file are ignored and the cache file is
+           overwritten with the defaults set in the class. This is useful if
+           you don't want previously used settings from the cache file being
+           used again'''
         fname = 'fake_review_settings.p'
         self.LOCATION = os.path.join(SOFTWARE_CENTER_CACHE_DIR, fname)
         if defaults:
             self._save_settings()
         else:
             self._update_from_file()
-        return
-    
+
     def update_setting(self, key_name, new_value):
-        '''Takes a string (key_name) which corresponds to a setting in this object 
-        and updates it with the value passed in (new_value).
+        '''Takes a string (key_name) which corresponds to a setting in this
+        object and updates it with the value passed in (new_value).
         Raises a NameError if the setting name doesn't exist'''
-       
+
         if not key_name in self._FAKE_SETTINGS:
-            raise NameError ('Setting key name %s does not exist' % key_name)
+            raise NameError('Setting key name %s does not exist' % key_name)
         else:
             self._FAKE_SETTINGS[key_name] = new_value
             self._save_settings()
         return
-    
+
     def update_multiple(self, settings):
-        '''Takes a dict (settings) of key,value pairs to perform multiple updates 
-           in one action, then saves. Dict being passed should contain only keys that 
-           match settings in this object or a NameError will be raised'''
+        '''Takes a dict (settings) of key,value pairs to perform multiple
+           updates in one action, then saves. Dict being passed should contain
+           only keys that match settings in this object or a NameError will be
+           raised'''
         for key, value in settings.items():
             if not key in self._FAKE_SETTINGS:
-                raise NameError ('Setting key name %s does not exist' % key)
-        
+                raise NameError('Setting key name %s does not exist' % key)
+
         for key, value in settings.items():
             self._FAKE_SETTINGS[key] = value
         self._save_settings()
         return
-    
+
     def get_setting(self, key_name):
-        '''Takes a string (key_name) which corresponds to a setting in this object, 
-        gets the latest copy of it from the file and returns the setting.
-        Raises a NameError if the setting name doesn't exist'''
+        '''Takes a string (key_name) which corresponds to a setting in this
+        object, gets the latest copy of it from the file and returns the
+        setting.  Raises a NameError if the setting name doesn't exist'''
         if not key_name in self._FAKE_SETTINGS:
-            raise NameError ('Setting %s does not exist' % key_name)
+            raise NameError('Setting %s does not exist' % key_name)
         else:
             self._update_from_file()
             return self._FAKE_SETTINGS[key_name]
-            
+
     def _update_from_file(self):
         '''Loads existing settings from cache file into _FAKE_SETTINGS dict'''
         if os.path.exists(self.LOCATION):
             try:
                 self._FAKE_SETTINGS = pickle.load(open(self.LOCATION))
             except:
-                os.rename(self.LOCATION, self.LOCATION+".fail")
+                os.rename(self.LOCATION, self.LOCATION + ".fail")
         return
-    
+
     def _save_settings(self):
         """write the dict out to cache file"""
         try:
 
=== modified file 'softwarecenter/backend/installbackend.py'
--- softwarecenter/backend/installbackend.py	2012-02-07 16:56:40 +0000
+++ softwarecenter/backend/installbackend.py	2012-03-19 14:27:20 +0000
@@ -18,32 +18,46 @@
 
 from softwarecenter.utils import UnimplementedError
 
+
 class InstallBackend(object):
     def __init__(self):
         self.pending_transactions = {}
         self.pending_purchases = []
 
-    def upgrade(self, app, iconname, addons_install=[], addons_remove=[], metadata=None):
-        pass
-    def remove(self, app, iconname, addons_install=[], addons_remove=[], metadata=None):
-        pass
-    def remove_multiple(self, apps, iconnames, addons_install=[], addons_remove=[], metadatas=None):
-        pass
-    def install(self, app, iconname, filename=None, addons_install=[], addons_remove=[], metadata=None):
-        pass
-    def install_multiple(self, apps, iconnames, addons_install=[], addons_remove=[], metadatas=None):
-        pass
-    def apply_changes(self, app, iconname, addons_install=[], addons_remove=[], metadata=None):
-        pass
+    def upgrade(self, app, iconname, addons_install=[], addons_remove=[],
+        metadata=None):
+        pass
+
+    def remove(self, app, iconname, addons_install=[], addons_remove=[],
+        metadata=None):
+        pass
+
+    def remove_multiple(self, apps, iconnames, addons_install=[],
+        addons_remove=[], metadatas=None):
+        pass
+
+    def install(self, app, iconname, filename=None, addons_install=[],
+        addons_remove=[], metadata=None):
+        pass
+
+    def install_multiple(self, apps, iconnames, addons_install=[],
+        addons_remove=[], metadatas=None):
+        pass
+
+    def apply_changes(self, app, iconname, addons_install=[],
+        addons_remove=[], metadata=None):
+        pass
+
     def reload(self, sources_list=None, metadata=None):
         """ reload package list """
         pass
 
+
 class InstallBackendUI(object):
 
     def ask_config_file_conflict(self, old, new):
         """ show a conffile conflict and ask what to do
-            Return "keep" to keep the old one 
+            Return "keep" to keep the old one
                    "replace" to replace the old with the new one
         """
         raise UnimplementedError("need custom ask_config_file_conflict method")
@@ -53,24 +67,27 @@
             return True if medium is provided, False to cancel
         """
         raise UnimplementedError("need custom ask_medium_required method")
-        
-    def error(self, parent, primary, secondary, details=None, alternative_action=None):
+
+    def error(self, parent, primary, secondary, details=None,
+        alternative_action=None):
         """ show an error dialog """
         raise UnimplementedError("need custom error method")
 
 
 # singleton
 install_backend = None
+
+
 def get_install_backend():
     global install_backend
     if install_backend is None:
         from softwarecenter.enums import USE_PACKAGEKIT_BACKEND
         if not USE_PACKAGEKIT_BACKEND:
-            from softwarecenter.backend.installbackend_impl.aptd import AptdaemonBackend
+            from softwarecenter.backend.installbackend_impl.aptd import (
+                AptdaemonBackend)
             install_backend = AptdaemonBackend()
         else:
-            from softwarecenter.backend.installbackend_impl.packagekitd import PackagekitBackend
+            from softwarecenter.backend.installbackend_impl.packagekitd \
+                import PackagekitBackend
             install_backend = PackagekitBackend()
     return install_backend
-
-        
 
=== modified file 'softwarecenter/backend/launchpad.py'
--- softwarecenter/backend/launchpad.py	2012-02-13 19:56:12 +0000
+++ softwarecenter/backend/launchpad.py	2012-03-19 14:27:20 +0000
@@ -35,7 +35,7 @@
 # py3 compat
 try:
     from queue import Queue
-    Queue # pyflakes
+    Queue  # pyflakes
 except ImportError:
     from Queue import Queue
 
@@ -55,16 +55,18 @@
 LOGIN_STATE_AUTH_FAILURE = "auth-fail"
 LOGIN_STATE_USER_CANCEL = "user-cancel"
 
+
 class UserCancelException(Exception):
     """ user pressed cancel """
     pass
 
+
 class LaunchpadlibWorker(threading.Thread):
     """The launchpadlib worker thread - it does not touch the UI
        and only communicates via the following:
 
        "login_state" - the current LOGIN_STATE_* value
-       
+
        To input reviews call "queue_review()"
        When no longer needed, call "shutdown()"
     """
@@ -128,7 +130,7 @@
         try:
             self._launchpad = Launchpad.login_with(
                 'software-center', SERVICE_ROOT, cachedir,
-                allow_access_levels = access_level,
+                allow_access_levels=access_level,
                 authorizer_class=AuthorizeRequestTokenFromThread)
             self.display_name = self._launchpad.me.display_name
         except Exception as e:
@@ -141,7 +143,8 @@
             (service_root, launchpadlib_dir, cache_path,
              service_root_dir) = Launchpad._get_paths(SERVICE_ROOT, cachedir)
             credentials_path = os.path.join(service_root_dir, 'credentials')
-            consumer_credentials_path = os.path.join(credentials_path, 'software-center')
+            consumer_credentials_path = os.path.join(credentials_path,
+                'software-center')
             # ---
             if os.path.exists(consumer_credentials_path):
                 os.remove(consumer_credentials_path)
@@ -150,11 +153,12 @@
         self.login_state = LOGIN_STATE_SUCCESS
         self._logger.debug("/done %s" % self._launchpad)
 
+
 class AuthorizeRequestTokenFromThread(RequestTokenAuthorizationEngine):
     """ Internal helper that updates the login_state of
         the modul global lp_worker_thread object
     """
-    def __init__ (self, *args, **kwargs):
+    def __init__(self, *args, **kwargs):
         super(AuthorizeRequestTokenFromThread, self).__init__(*args, **kwargs)
         self._logger = logging.getLogger("softwarecenter.backend")
 
@@ -167,7 +171,7 @@
         return o
 
     def input_username(self, cached_username, suggested_message):
-        self._logger.debug( "input_username: %s" %self.lp_worker.login_state)
+        self._logger.debug("input_username: %s" % self.lp_worker.login_state)
         # otherwise go into ASK state
         if not self.lp_worker.login_state in (LOGIN_STATE_ASK_USER_AND_PASS,
                                               LOGIN_STATE_AUTH_FAILURE,
@@ -185,7 +189,8 @@
         return self.lp_worker.login_username
 
     def input_password(self, suggested_message):
-        self._logger.debug( "Input password size %s" % len(self.lp_worker.login_password))
+        self._logger.debug("Input password size %s" %
+            len(self.lp_worker.login_password))
         return self.lp_worker.login_password
 
     def input_access_level(self, available_levels, suggested_message,
@@ -217,7 +222,7 @@
     """
 
     NEW_ACCOUNT_URL = "https://login.launchpad.net/+standalone-login"
-    FORGOT_PASSWORD_URL =  "https://login.launchpad.net/+standalone-login"
+    FORGOT_PASSWORD_URL = "https://login.launchpad.net/+standalone-login"
 
     def __init__(self):
         LoginBackend.__init__(self)
@@ -238,13 +243,13 @@
         lp_worker_thread.shutdown()
 
     def enter_username_password(self, user, password):
-        """ 
+        """
         provider username and password, ususally used when the
         need-username-password signal was send
         """
         lp_worker_thread.login_username = user
         lp_worker_thread.login_password = password
-        lp_worker_thread.login_state = LOGIN_STATE_HAS_USER_AND_PASS        
+        lp_worker_thread.login_state = LOGIN_STATE_HAS_USER_AND_PASS
 
     def login(self, username=None, password=None):
         if username and password:
@@ -254,17 +259,17 @@
 
     def cancel_login(self):
         lp_worker_thread.login_state = LOGIN_STATE_USER_CANCEL
-    
+
     def get_subscribed_archives(self):
         """ return list of sources.list entries """
         urls = lp_worker_thread._launchpad.me.getArchiveSubscriptionURLs()
         return self._format_archive_subscription_urls_as_deb_lines(urls)
-    
+
     def _format_archive_subscription_urls_as_deb_lines(self, urls):
         deb_lines = ["deb %s %s main" % (url, self.distro.get_codename()) \
                      for url in urls]
         return deb_lines
-    
+
     def get_subscribed_archives_async(self, callback):
         """ get the available subscribed archives and run 'callback' when
             they become availalbe
@@ -300,10 +305,16 @@
     print ("success %s" % lp)
     print(lp.get_subscribed_archives())
     print(lp.get_subscribed_archives_async(_result_callback))
+
+
 def _login_failed(lp):
     print ("fail %s" % lp)
+
+
 def _result_callback(result_list):
     print("_result_callback %s" % result_list)
+
+
 def _login_need_user_and_password(lp):
     import sys
     sys.stdout.write("user: ")
 
=== modified file 'softwarecenter/backend/login.py'
--- softwarecenter/backend/login.py	2012-01-05 15:01:43 +0000
+++ softwarecenter/backend/login.py	2012-03-19 14:27:20 +0000
@@ -21,31 +21,33 @@
 
 from gi.repository import GObject
 
+
 class LoginBackend(GObject.GObject):
 
     NEW_ACCOUNT_URL = None
     FORGOT_PASSWORD_URL = None
 
     __gsignals__ = {
-        "login-successful" : (GObject.SIGNAL_RUN_LAST,
-                             GObject.TYPE_NONE, 
+        "login-successful": (GObject.SIGNAL_RUN_LAST,
+                             GObject.TYPE_NONE,
                              (GObject.TYPE_PYOBJECT,),
                             ),
-        "login-failed" : (GObject.SIGNAL_RUN_LAST,
-                          GObject.TYPE_NONE, 
-                          (),
-                         ),
-        "login-canceled" : (GObject.SIGNAL_RUN_LAST,
-                          GObject.TYPE_NONE, 
-                          (),
-                         ),
-        "need-username-password" : (GObject.SIGNAL_RUN_LAST,
-                                    GObject.TYPE_NONE, 
-                                    (),
-                                   ),
+        "login-failed": (GObject.SIGNAL_RUN_LAST,
+                         GObject.TYPE_NONE,
+                         (),
+                        ),
+        "login-canceled": (GObject.SIGNAL_RUN_LAST,
+                           GObject.TYPE_NONE,
+                           (),
+                          ),
+        "need-username-password": (GObject.SIGNAL_RUN_LAST,
+                                   GObject.TYPE_NONE,
+                                   (),
+                                  ),
         }
 
     def login(self, username=None, password=None):
         raise NotImplemented
+
     def cancel_login(self):
         self.emit("login-canceled")
 
=== modified file 'softwarecenter/backend/login_sso.py'
--- softwarecenter/backend/login_sso.py	2012-03-14 15:45:47 +0000
+++ softwarecenter/backend/login_sso.py	2012-03-19 14:27:20 +0000
@@ -36,6 +36,7 @@
 
 LOG = logging.getLogger(__name__)
 
+
 class LoginBackendDbusSSO(LoginBackend):
 
     def __init__(self, window_id, appname, help_text):
@@ -45,11 +46,11 @@
         self.bus = dbus.SessionBus()
         self.proxy = self.bus.get_object(
             'com.ubuntu.sso', '/com/ubuntu/sso/credentials')
-        self.proxy.connect_to_signal("CredentialsFound", 
+        self.proxy.connect_to_signal("CredentialsFound",
                                      self._on_credentials_found)
-        self.proxy.connect_to_signal("CredentialsError", 
+        self.proxy.connect_to_signal("CredentialsError",
                                      self._on_credentials_error)
-        self.proxy.connect_to_signal("AuthorizationDenied", 
+        self.proxy.connect_to_signal("AuthorizationDenied",
                                      self._on_authorization_denied)
         self._window_id = window_id
         self._credentials = None
@@ -66,7 +67,7 @@
         LOG.debug("login()")
         self._credentials = None
         self.proxy.login(self.appname, self._get_params())
-        
+
     def login_or_register(self):
         LOG.debug("login_or_register()")
         self._credentials = None
@@ -82,7 +83,6 @@
         if self._credentials != credentials:
             self.emit("login-successful", credentials)
         self._credentials = credentials
-        
 
     def _on_credentials_error(self, app_name, error, detailed_error=""):
         LOG.error("_on_credentails_error for %s: %s (%s)" % (
@@ -107,55 +107,62 @@
         self.help_text = help_text
         self._window_id = window_id
         self._fake_settings = FakeReviewSettings()
-    
+
     @network_delay
     def login(self, username=None, password=None):
         response = self._fake_settings.get_setting('login_response')
-            
+
         if response == "successful":
             self.emit("login-successful", self._return_credentials())
         elif response == "failed":
             self.emit("login-failed")
         elif response == "denied":
             self.cancel_login()
-        
+
         return
-    
+
     def login_or_register(self):
         #fake functionality for this is no different to fake login()
         self.login()
         return
-                
+
     def _random_unicode_string(self, length):
         retval = ''
-        for i in range(0,length):
+        for i in range(0, length):
             retval = retval + random.choice(string.letters + string.digits)
         return retval.decode('utf-8')
- 
+
     def _return_credentials(self):
-        c =  dbus.Dictionary(
+        c = dbus.Dictionary(
             {
-              dbus.String(u'consumer_secret'): dbus.String(self._random_unicode_string(30)),
-              dbus.String(u'token') : dbus.String(self._random_unicode_string(50)),
-              dbus.String(u'consumer_key') : dbus.String(self._random_unicode_string(7)),
-              dbus.String(u'name') : dbus.String('Ubuntu Software Center @ ' + self._random_unicode_string(6)),
-              dbus.String(u'token_secret') : dbus.String(self._random_unicode_string(50))
-             }, 
+              dbus.String(u'consumer_secret'): dbus.String(
+                self._random_unicode_string(30)),
+              dbus.String(u'token'): dbus.String(
+                self._random_unicode_string(50)),
+              dbus.String(u'consumer_key'): dbus.String(
+                self._random_unicode_string(7)),
+              dbus.String(u'name'): dbus.String('Ubuntu Software Center @ ' +
+                self._random_unicode_string(6)),
+              dbus.String(u'token_secret'): dbus.String(
+                self._random_unicode_string(50))
+             },
              signature=dbus.Signature('ss')
              )
         return c
 
+
 def get_sso_backend(window_id, appname, help_text):
-    """ 
+    """
     factory that returns an sso loader singelton
     """
     if "SOFTWARE_CENTER_FAKE_REVIEW_API" in os.environ:
         sso_class = LoginBackendDbusSSOFake(window_id, appname, help_text)
-        LOG.warn('Using fake login SSO functionality. Only meant for testing purposes')
+        LOG.warn('Using fake login SSO functionality. Only meant for '
+            'testing purposes')
     else:
         sso_class = LoginBackendDbusSSO(window_id, appname, help_text)
     return sso_class
-   
+
 if __name__ == "__main__":
     logging.basicConfig(level=logging.DEBUG)
 
 
=== modified file 'softwarecenter/backend/recagent.py'
--- softwarecenter/backend/recagent.py	2012-03-12 21:28:10 +0000
+++ softwarecenter/backend/recagent.py	2012-03-19 14:27:20 +0000
@@ -31,47 +31,48 @@
 
 LOG = logging.getLogger(__name__)
 
+
 class RecommenderAgent(GObject.GObject):
 
     __gsignals__ = {
-        "server-status" : (GObject.SIGNAL_RUN_LAST,
-                           GObject.TYPE_NONE, 
-                           (GObject.TYPE_PYOBJECT,),
-                          ),
-        "profile" : (GObject.SIGNAL_RUN_LAST,
-                     GObject.TYPE_NONE, 
-                     (GObject.TYPE_PYOBJECT,),
-                    ),
-        "submit-profile-finished" : (GObject.SIGNAL_RUN_LAST,
-                            GObject.TYPE_NONE, 
-                            (GObject.TYPE_PYOBJECT, str),
-                           ),
-        "submit-anon-profile-finished" : (GObject.SIGNAL_RUN_LAST,
-                                 GObject.TYPE_NONE, 
-                                 (GObject.TYPE_PYOBJECT,),
-                                ),
-        "recommend-me" : (GObject.SIGNAL_RUN_LAST,
-                              GObject.TYPE_NONE, 
-                              (GObject.TYPE_PYOBJECT,),
-                             ),
-        "recommend-app" : (GObject.SIGNAL_RUN_LAST,
-                           GObject.TYPE_NONE, 
-                           (GObject.TYPE_PYOBJECT,),
-                          ),
-        "recommend-all-apps" : (GObject.SIGNAL_RUN_LAST,
-                                GObject.TYPE_NONE, 
-                                (GObject.TYPE_PYOBJECT,),
-                               ),
-        "recommend-top" : (GObject.SIGNAL_RUN_LAST,
-                           GObject.TYPE_NONE, 
-                           (GObject.TYPE_PYOBJECT,),
-                          ),
-        "error" : (GObject.SIGNAL_RUN_LAST,
-                   GObject.TYPE_NONE, 
-                   (str,),
-                  ),
+        "server-status": (GObject.SIGNAL_RUN_LAST,
+                          GObject.TYPE_NONE,
+                          (GObject.TYPE_PYOBJECT,),
+                         ),
+        "profile": (GObject.SIGNAL_RUN_LAST,
+                    GObject.TYPE_NONE,
+                    (GObject.TYPE_PYOBJECT,),
+                   ),
+        "submit-profile-finished": (GObject.SIGNAL_RUN_LAST,
+                                    GObject.TYPE_NONE,
+                                    (GObject.TYPE_PYOBJECT, str),
+                                   ),
+        "submit-anon-profile-finished": (GObject.SIGNAL_RUN_LAST,
+                                         GObject.TYPE_NONE,
+                                         (GObject.TYPE_PYOBJECT,),
+                                        ),
+        "recommend-me": (GObject.SIGNAL_RUN_LAST,
+                         GObject.TYPE_NONE,
+                         (GObject.TYPE_PYOBJECT,),
+                        ),
+        "recommend-app": (GObject.SIGNAL_RUN_LAST,
+                          GObject.TYPE_NONE,
+                          (GObject.TYPE_PYOBJECT,),
+                         ),
+        "recommend-all-apps": (GObject.SIGNAL_RUN_LAST,
+                               GObject.TYPE_NONE,
+                               (GObject.TYPE_PYOBJECT,),
+                              ),
+        "recommend-top": (GObject.SIGNAL_RUN_LAST,
+                          GObject.TYPE_NONE,
+                          (GObject.TYPE_PYOBJECT,),
+                         ),
+        "error": (GObject.SIGNAL_RUN_LAST,
+                  GObject.TYPE_NONE,
+                  (str,),
+                 ),
         }
-    
+
     def __init__(self, xid=None):
         GObject.GObject.__init__(self)
         self.xid = xid
@@ -86,17 +87,17 @@
         spawner.connect("error", lambda spawner, err: self.emit("error", err))
         spawner.run_generic_piston_helper(
             "SoftwareCenterRecommenderAPI", "server_status")
-            
+
     def post_submit_profile(self, db):
         """ This will post the users profile to the recommender server
-            and also generate the UUID for the user if that is not 
+            and also generate the UUID for the user if that is not
             there yet
         """
         # if we have not already set a recommender UUID, now is the time
         # to do it
         if not self.recommender_uuid:
             self.recommender_uuid = get_uuid()
-        installed_pkglist = [app.pkgname 
+        installed_pkglist = [app.pkgname
                              for app in get_installed_apps_list(db)]
         data = self._generate_submit_profile_data(self.recommender_uuid,
                                                   installed_pkglist)
@@ -110,7 +111,7 @@
             "SoftwareCenterRecommenderAPI",
             "submit_profile",
             data=data)
-            
+
     def post_submit_anon_profile(self, uuid, installed_packages, extra):
         # build the command
         spawner = SpawnHelper()
@@ -124,7 +125,7 @@
             uuid=uuid,
             installed_packages=installed_packages,
             extra=extra)
-            
+
     def query_profile(self, pkgnames):
         # build the command
         spawner = SpawnHelper()
@@ -146,7 +147,7 @@
         spawner.connect("error", lambda spawner, err: self.emit("error", err))
         spawner.run_generic_piston_helper(
             "SoftwareCenterRecommenderAPI", "recommend_me")
-            
+
     def query_recommend_app(self, pkgname):
         # build the command
         spawner = SpawnHelper()
@@ -157,7 +158,7 @@
             "SoftwareCenterRecommenderAPI",
             "recommend_app",
             pkgname=pkgname)
-            
+
     def query_recommend_all_apps(self):
         # build the command
         spawner = SpawnHelper()
@@ -166,7 +167,7 @@
         spawner.connect("error", lambda spawner, err: self.emit("error", err))
         spawner.run_generic_piston_helper(
             "SoftwareCenterRecommenderAPI", "recommend_all_apps")
-            
+
     def query_recommend_top(self):
         # build the command
         spawner = SpawnHelper()
@@ -175,7 +176,7 @@
         spawner.connect("error", lambda spawner, err: self.emit("error", err))
         spawner.run_generic_piston_helper(
             "SoftwareCenterRecommenderAPI", "recommend_top")
-            
+
     def is_opted_in(self):
         """
         Return True is the user is currently opted-in to the recommender
@@ -185,33 +186,34 @@
             return True
         else:
             return False
-            
+
     def _on_server_status_data(self, spawner, piston_server_status):
         self.emit("server-status", piston_server_status)
-        
+
     def _on_profile_data(self, spawner, piston_profile):
         self.emit("profile", piston_profile)
-        
+
     def _on_submit_profile_data(self, spawner, piston_submit_profile):
-        self.emit("submit-profile-finished", 
-                  piston_submit_profile, 
+        self.emit("submit-profile-finished",
+                  piston_submit_profile,
                   self.recommender_uuid)
-        
-    def _on_submit_anon_profile_data(self, spawner, piston_submit_anon_profile):
+
+    def _on_submit_anon_profile_data(self, spawner,
+        piston_submit_anon_profile):
         self.emit("submit-anon_profile", piston_submit_anon_profile)
 
     def _on_recommend_me_data(self, spawner, piston_me_apps):
         self.emit("recommend-me", piston_me_apps)
-        
+
     def _on_recommend_app_data(self, spawner, piston_app):
         self.emit("recommend-app", piston_app)
-        
+
     def _on_recommend_all_apps_data(self, spawner, piston_all_apps):
         self.emit("recommend-all-apps", piston_all_apps)
-        
+
     def _on_recommend_top_data(self, spawner, piston_top_apps):
         self.emit("recommend-top", piston_top_apps)
-        
+
     def _get_recommender_uuid(self):
         """ returns the recommender UUID value, which can be empty if it
             has not yet been set (indicating that the user has not yet
@@ -223,24 +225,24 @@
             if recommender_uuid:
                 return recommender_uuid
         return ""
-        
+
     def _generate_submit_profile_data(self, recommender_uuid, package_list):
-        submit_profile_data = [
-            {
-                'uuid': recommender_uuid, 
-                'package_list': package_list
-            }
-        ]
+        submit_profile_data = [{
+            'uuid': recommender_uuid,
+            'package_list': package_list
+        }]
         return submit_profile_data
 
-   
+
 if __name__ == "__main__":
     from gi.repository import Gtk
 
     def _recommend_top(agent, top_apps):
         print ("_recommend_top: %s" % top_apps)
+
     def _recommend_me(agent, top_apps):
         print ("_recommend_me: %s" % top_apps)
+
     def _error(agent, msg):
         print ("got a error: %s" % msg)
         Gtk.main_quit()
@@ -256,5 +258,4 @@
     agent.query_recommend_top()
     agent.query_recommend_me()
 
-
     Gtk.main()
 
=== modified file 'softwarecenter/backend/scagent.py'
--- softwarecenter/backend/scagent.py	2012-01-17 15:56:14 +0000
+++ softwarecenter/backend/scagent.py	2012-03-19 14:27:20 +0000
@@ -29,27 +29,28 @@
 
 LOG = logging.getLogger(__name__)
 
+
 class SoftwareCenterAgent(GObject.GObject):
 
     __gsignals__ = {
-        "available-for-me" : (GObject.SIGNAL_RUN_LAST,
-                              GObject.TYPE_NONE, 
-                              (GObject.TYPE_PYOBJECT,),
-                             ),
-        "available" : (GObject.SIGNAL_RUN_LAST,
-                              GObject.TYPE_NONE, 
-                              (GObject.TYPE_PYOBJECT,),
-                             ),
-        "exhibits" : (GObject.SIGNAL_RUN_LAST,
-                              GObject.TYPE_NONE, 
-                              (GObject.TYPE_PYOBJECT,),
-                             ),
-        "error" : (GObject.SIGNAL_RUN_LAST,
-                   GObject.TYPE_NONE, 
-                   (str,),
-                  ),
+        "available-for-me": (GObject.SIGNAL_RUN_LAST,
+                             GObject.TYPE_NONE,
+                             (GObject.TYPE_PYOBJECT,),
+                            ),
+        "available": (GObject.SIGNAL_RUN_LAST,
+                      GObject.TYPE_NONE,
+                      (GObject.TYPE_PYOBJECT,),
+                     ),
+        "exhibits": (GObject.SIGNAL_RUN_LAST,
+                     GObject.TYPE_NONE,
+                     (GObject.TYPE_PYOBJECT,),
+                    ),
+        "error": (GObject.SIGNAL_RUN_LAST,
+                  GObject.TYPE_NONE,
+                  (str,),
+                 ),
         }
-    
+
     def __init__(self, ignore_cache=False, xid=None):
         GObject.GObject.__init__(self)
         self.distro = get_distro()
@@ -103,7 +104,8 @@
             "SoftwareCenterAgentAPI", "subscriptions_for_me",
             complete_only=True)
 
-    def _on_query_available_for_me_data(self, spawner, piston_available_for_me):
+    def _on_query_available_for_me_data(self, spawner,
+        piston_available_for_me):
         self.emit("available-for-me", piston_available_for_me)
 
     def query_exhibits(self):
@@ -113,7 +115,7 @@
         spawner.connect("data-available", self._on_exhibits_data_available)
         spawner.connect("error", lambda spawner, err: self.emit("error", err))
         spawner.run_generic_piston_helper(
-            "SoftwareCenterAgentAPI", "exhibits", 
+            "SoftwareCenterAgentAPI", "exhibits",
             lang=get_language(), series=self.distro.get_codename())
 
     def _on_exhibits_data_available(self, spawner, exhibits):
@@ -123,18 +125,22 @@
             if not hasattr(exhibit, "title_translated"):
                 if exhibit.html:
                     from softwarecenter.utils import get_title_from_html
-                    exhibit.title_translated = get_title_from_html(exhibit.html)
+                    exhibit.title_translated = get_title_from_html(
+                        exhibit.html)
                 else:
                     exhibit.title_translated = ""
         self.emit("exhibits", exhibits)
-        
+
 if __name__ == "__main__":
     def _available(agent, available):
         print ("_available: %s" % available)
+
     def _available_for_me(agent, available_for_me):
         print ("_availalbe_for_me: %s" % available_for_me)
+
     def _exhibits(agent, exhibits):
         print ("exhibits: " % exhibits)
+
     def _error(agent, msg):
         print ("got a error" % msg)
         #gtk.main_quit()
 
=== modified file 'softwarecenter/hw.py'
--- softwarecenter/hw.py	2012-03-19 11:32:58 +0000
+++ softwarecenter/hw.py	2012-03-19 14:27:20 +0000
@@ -79,10 +79,12 @@
                                    u'computer is using.'),
 }
 
+
 def get_hw_short_description(tag):
     s = TAG_DESCRIPTION.get(tag)
     return utf8(s)
 
+
 def get_hw_missing_long_description(tags):
     s = ""
     # build string
@@ -94,7 +96,7 @@
             else:
                 # deal with generic tags
                 prefix, sep, postfix = tag.rpartition(":")
-                descr =  TAG_MISSING_DESCRIPTION.get(prefix+sep)
+                descr = TAG_MISSING_DESCRIPTION.get(prefix + sep)
                 descr = descr % postfix
                 if descr:
                     s += "%s\n" % descr
@@ -116,8 +118,9 @@
                 res[tag] = debtagshw.enums.HardwareSupported.YES
     return res
 
+
 def get_hardware_support_for_tags(tags):
-    """ wrapper around the DebtagsAvailalbeHW to support adding our own 
+    """ wrapper around the DebtagsAvailalbeHW to support adding our own
         private tag extension (like opengl-driver)
     """
     from debtagshw.debtagshw import DebtagsAvailableHW
 
=== modified file 'softwarecenter/testutils.py'
--- softwarecenter/testutils.py	2012-03-15 21:19:02 +0000
+++ softwarecenter/testutils.py	2012-03-19 14:27:20 +0000
@@ -230,7 +230,7 @@
             },
             {
                 u'package_name': u'mangler'
-            }, 
+            },
             {
                 u'package_name': u'nexuiz'
             },
@@ -254,7 +254,7 @@
             },
             {
                 u'package_name': u'psi'
-            }, 
+            },
             {
                 u'package_name': u'midori'
             }
@@ -282,7 +282,6 @@
                 u'phlipple',
                 u'psi',
                 u'midori'
-                
             ]
         }
     ]
 
=== modified file 'softwarecenter/utils.py'
--- softwarecenter/utils.py	2012-03-16 17:22:59 +0000
+++ softwarecenter/utils.py	2012-03-19 14:27:20 +0000
@@ -253,7 +253,7 @@
     # well ... it segfaults (thanks pygi)
     key = "org.gnome.system.proxy.http"
     if not key in Gio.Settings.list_schemas():
-        raise ValueError, "no key '%s'" % key
+        raise ValueError("no key '%s'" % key)
     settings = Gio.Settings.new(key)
     if settings.get_string("host"):
         authentication = ""
 
=== modified file 'test/test_pep8.py'
--- test/test_pep8.py	2012-03-19 14:27:20 +0000
+++ test/test_pep8.py	2012-03-19 14:27:20 +0000
@@ -7,21 +7,12 @@
 setup_test_env()
 
 # Only test these two packages for now:
-import softwarecenter.backend
-import softwarecenter.db
-import softwarecenter.ui
-import softwarecenter.distro
+import softwarecenter
 
 class PackagePep8TestCase(unittest.TestCase):
     maxDiff = None
-    packages = [softwarecenter.ui,
-                softwarecenter.backend,
-                softwarecenter.db,
-                softwarecenter.distro,
-               ]
-    exclude = ['scagent.py', 'recagent.py', 'login_sso.py', 'login.py',
-        'launchpad.py', 'installbackend.py', 'fake_review_settings.py',
-        'channel.py']
+    packages = [softwarecenter]
+    exclude = []
 
     def message(self, text):
         self.errors.append(text)