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

[Anthony Lenton]

Made several files under softwarecenter/db/ pass the pep8 test.

=== modified file 'softwarecenter/db/history_impl/apthistory.py'
--- softwarecenter/db/history_impl/apthistory.py	2011-12-02 14:30:56 +0000
+++ softwarecenter/db/history_impl/apthistory.py	2012-03-15 04:06:19 +0000
@@ -33,7 +33,7 @@
 
 try:
     import cPickle as pickle
-    pickle # pyflakes
+    pickle  # pyflakes
 except ImportError:
     import pickle
 
@@ -43,20 +43,22 @@
 from softwarecenter.utils import ExecutionTime
 from softwarecenter.db.history import Transaction, PackageHistory
 
+
 def ascii_lower(key):
     ascii_trans_table = string.maketrans(string.ascii_uppercase,
                                         string.ascii_lowercase)
     return key.translate(ascii_trans_table)
 
+
 class AptTransaction(Transaction):
-    PKGACTIONS=["Install", "Upgrade", "Downgrade", "Remove", "Purge"]
+    PKGACTIONS = ["Install", "Upgrade", "Downgrade", "Remove", "Purge"]
 
     def __init__(self, sec):
         self.start_date = datetime.strptime(sec["Start-Date"],
                                             "%Y-%m-%d  %H:%M:%S")
         # set the object attributes "install", "upgrade", "downgrade",
         #                           "remove", "purge", error
-        for k in self.PKGACTIONS+["Error"]:
+        for k in self.PKGACTIONS + ["Error"]:
             # we use ascii_lower for issues described in LP: #581207
             attr = ascii_lower(k)
             if k in sec:
@@ -68,13 +70,14 @@
     @staticmethod
     def _fixup_history_item(s):
         """ strip history item string and add missing ")" if needed """
-        s=s.strip()
+        s = s.strip()
         # remove the infomation about the architecture
         s = re.sub(":\w+", "", s)
         if "(" in s and not s.endswith(")"):
-            s+=")"
+            s += ")"
         return s
 
+
 class AptHistory(PackageHistory):
 
     def __init__(self, use_cache=True):
@@ -95,6 +98,7 @@
     @property
     def transactions(self):
         return self._transactions
+
     @property
     def history_ready(self):
         return self._history_ready
@@ -114,7 +118,7 @@
                     cachetime = os.path.getmtime(p)
                 except:
                     LOG.exception("failed to load cache")
-        for history_gz_file in sorted(glob.glob(self.history_file+".*.gz"),
+        for history_gz_file in sorted(glob.glob(self.history_file + ".*.gz"),
                                       cmp=self._mtime_cmp):
             if os.path.getmtime(history_gz_file) < cachetime:
                 LOG.debug("skipping already cached '%s'" % history_gz_file)
@@ -124,8 +128,8 @@
         if use_cache:
             pickle.dump(self._transactions, open(p, "w"))
         self._history_ready = True
-    
-    def _scan(self, history_file, rescan = False):
+
+    def _scan(self, history_file, rescan=False):
         LOG.debug("_scan: '%s' (%s)" % (history_file, rescan))
         try:
             tagfile = apt_pkg.TagFile(open(history_file))
@@ -136,7 +140,7 @@
             # keep the UI alive
             while self.main_context.pending():
                 self.main_context.iteration()
-            # ignore records with 
+            # ignore records with
             try:
                 trans = AptTransaction(stanza)
             except (KeyError, ValueError):
@@ -151,16 +155,16 @@
             #        so we could (and should) do a binary search
             if not trans in self._transactions:
                 self._transactions.insert(0, trans)
-            
+
     def _on_apt_history_changed(self, monitor, afile, other_file, event):
-        if event ==  Gio.FileMonitorEvent.CHANGES_DONE_HINT:
-            self._scan(self.history_file, rescan = True)
+        if event == Gio.FileMonitorEvent.CHANGES_DONE_HINT:
+            self._scan(self.history_file, rescan=True)
             if self.update_callback:
                 self.update_callback()
-    
-    def set_on_update(self,update_callback):
-        self.update_callback=update_callback
-            
+
+    def set_on_update(self, update_callback):
+        self.update_callback = update_callback
+
     def get_installed_date(self, pkg_name):
         installed_date = None
         for trans in self._transactions:
@@ -169,7 +173,7 @@
                     installed_date = trans.start_date
                     return installed_date
         return installed_date
-    
+
     def _find_in_terminal_log(self, date, term_file):
         found = False
         term_lines = []
@@ -191,9 +195,8 @@
         term_lines = self._find_in_terminal_log(date, open(term))
         # now search the older history
         if not term_lines:
-            for f in glob.glob(term+".*.gz"):
+            for f in glob.glob(term + ".*.gz"):
                 term_lines = self._find_in_terminal_log(date, gzip.open(f))
                 if term_lines:
                     return term_lines
         return term_lines
-
 
=== modified file 'softwarecenter/db/history_impl/packagekit.py'
--- softwarecenter/db/history_impl/packagekit.py	2011-12-02 14:30:56 +0000
+++ softwarecenter/db/history_impl/packagekit.py	2012-03-15 04:06:19 +0000
@@ -22,6 +22,7 @@
 
 LOG = logging.getLogger(__name__)
 
+
 class PackagekitTransaction(Transaction):
     def __init__(self, pktrans):
         self.start_date = datetime.strptime(pktrans.props.timespec,
@@ -31,7 +32,8 @@
         self.upgrade = []
         self.downgrade = []
         self.remove = []
-        self.purge = [] # can't happen with a Packagekit backend (is mapped to remove)
+        self.purge = []  # can't happen with a Packagekit backend (is mapped
+                         # to remove)
 
         # parse transaction data
         lines = pktrans.props.data.split('\n')
@@ -51,13 +53,15 @@
                 elif action == 'removing':
                     self.remove.append(package_name)
                 else:
-                    # ignore other actions (include cleanup, downloading and untrusted)
+                    # ignore other actions (include cleanup, downloading and
+                    # untrusted)
                     continue
             except:
                 LOG.warn("malformed line emitted by PackageKit, was %s" % line)
 
+
 class PackagekitHistory(PackageHistory):
-    """ Represents the history of the transactions """    
+    """ Represents the history of the transactions """
 
     def __init__(self, use_cache=True):
         self._use_cache = use_cache
@@ -66,9 +70,9 @@
 
         self._client = PackageKitGlib.Client()
         self._client.get_old_transactions_async(0,
-                                                None, # cancellable
-                                                lambda *args, **kwargs: None, None, # progress callback
-                                                self._transactions_received, None)
+            None,  # cancellable
+            lambda *args, **kwargs: None, None,  # progress callback
+            self._transactions_received, None)
 
     @property
     def history_ready(self):
@@ -86,7 +90,7 @@
 
     def get_installed_date(self, pkg_name):
         """Return the date that the given package name got instaled """
-        return None
+        pass
 
     def _transactions_received(self, client, async_result, user_data):
         try:
 
=== modified file 'softwarecenter/db/pkginfo.py'
--- softwarecenter/db/pkginfo.py	2012-02-14 09:51:45 +0000
+++ softwarecenter/db/pkginfo.py	2012-03-15 04:06:19 +0000
@@ -18,28 +18,36 @@
 
 from gi.repository import GObject
 
+
 class _Version:
     @property
     def description(self):
         pass
+
     @property
     def downloadable(self):
         pass
+
     @property
     def summary(self):
         pass
+
     @property
     def size(self):
         return self.pkginfo.get_size(self.name)
+
     @property
     def installed_size(self):
         return 0
+
     @property
     def version(self):
         pass
+
     @property
     def origins(self):
         return []
+
     @property
     def not_automatic(self):
         """ should not be installed/upgraded automatically, the user needs
@@ -47,22 +55,26 @@
         """
         return False
 
+
 class _Package:
     def __init__(self, name, pkginfo):
         self.name = name
         self.pkginfo = pkginfo
+
     def __str__(self):
-        return repr(self).replace('<',  '<pkgname=%s ' % self.name)
+        return repr(self).replace('<', '<pkgname=%s ' % self.name)
+
     @property
     def installed(self):
         """ returns a _Version object """
-        if not self.pkginfo.is_installed(self.name):
-            return None
-        return self.pkginfo.get_installed(self.name)
+        if self.pkginfo.is_installed(self.name):
+            return self.pkginfo.get_installed(self.name)
+
     @property
     def candidate(self):
         """ returns a _Version object """
         return self.pkginfo.get_candidate(self.name)
+
     @property
     def versions(self):
         """ a list of available versions (as _Version) to install """
@@ -71,18 +83,23 @@
     @property
     def is_installed(self):
         return self.pkginfo.is_installed(self.name)
+
     @property
     def is_upgradable(self):
         return self.pkginfo.is_upgradable(self.name)
+
     @property
     def section(self):
         return self.pkginfo.get_section(self.name)
+
     @property
     def website(self):
         return self.pkginfo.get_website(self.name)
+
     @property
     def installed_files(self):
         return self.pkginfo.get_installed_files(self.name)
+
     @property
     def description(self):
         return self.pkginfo.get_description(self.name)
@@ -91,22 +108,24 @@
     def license(self):
         return self.pkginfo.get_license(self.name)
 
+
 class PackageInfo(GObject.GObject):
     """ abstract interface for the packageinfo information """
 
-    __gsignals__ = {'cache-ready':  (GObject.SIGNAL_RUN_FIRST,
-                                     GObject.TYPE_NONE,
-                                     ()),
-                    'cache-invalid':(GObject.SIGNAL_RUN_FIRST,
-                                     GObject.TYPE_NONE,
-                                     ()),
-                    'cache-broken':(GObject.SIGNAL_RUN_FIRST,
-                                     GObject.TYPE_NONE,
-                                     ()),
+    __gsignals__ = {'cache-ready': (GObject.SIGNAL_RUN_FIRST,
+                                    GObject.TYPE_NONE,
+                                    ()),
+                    'cache-invalid': (GObject.SIGNAL_RUN_FIRST,
+                                      GObject.TYPE_NONE,
+                                      ()),
+                    'cache-broken': (GObject.SIGNAL_RUN_FIRST,
+                                      GObject.TYPE_NONE,
+                                      ()),
                     }
 
     def __getitem__(self, k):
         return _Package(k, self)
+
     def __contains__(self, pkgname):
         return False
 
@@ -114,10 +133,12 @@
     def version_compare(v1, v2):
         """ compare two versions """
         return cmp(v1, v2)
+
     @staticmethod
     def upstream_version_compare(v1, v2):
         """ compare two versions, but ignore the distro specific revisions """
         return cmp(v1, v2)
+
     @staticmethod
     def upstream_version(v):
         """ Return the "upstream" version number of the given version """
@@ -125,34 +146,47 @@
 
     def is_installed(self, pkgname):
         pass
+
     def is_available(self, pkgname):
         pass
+
     def get_installed(self, pkgname):
         pass
+
     def get_candidate(self, pkgname):
         pass
+
     def get_versions(self, pkgname):
         return []
 
     def get_section(self, pkgname):
         pass
+
     def get_summary(self, pkgname):
         pass
+
     def get_description(self, pkgname):
         pass
+
     def get_website(self, pkgname):
         pass
+
     def get_installed_files(self, pkgname):
         return []
+
     def get_size(self, pkgname):
         return -1
+
     def get_installed_size(self, pkgname):
         return -1
+
     def get_origins(self, pkgname):
         return []
+
     def get_origin(self, pkgname):
         """ :return: unique origin as string """
         return ''
+
     def get_addons(self, pkgname, ignore_installed=False):
         """ :return: a tuple of pkgnames (recommends, suggests) """
         return ([], [])
@@ -167,27 +201,30 @@
         which will be removed if the package is installed."""
         return []
 
-    def get_total_size_on_install(self, pkgname, 
+    def get_total_size_on_install(self, pkgname,
                                   addons_install=None, addons_remove=None,
                                   archive_suite=None):
         """ Returns a tuple (download_size, installed_size)
         with disk size in KB calculated for pkgname installation
-        plus addons change and a (optional) archive_suite that the 
+        plus addons change and a (optional) archive_suite that the
         package comes from
         """
         return (0, 0)
 
     def open(self):
-        """ 
+        """
         (re)open the cache, this sends cache-invalid, cache-ready signals
         """
         pass
+
     @property
     def ready(self):
         pass
 
 # singleton
 pkginfo = None
+
+
 def get_pkg_info():
     global pkginfo
     if pkginfo is None:
@@ -196,6 +233,8 @@
             from softwarecenter.db.pkginfo_impl.aptcache import AptCache
             pkginfo = AptCache()
         else:
-            from softwarecenter.db.pkginfo_impl.packagekit import PackagekitInfo
-            pkginfo = PackagekitInfo()        
+            from softwarecenter.db.pkginfo_impl.packagekit import (
+                PackagekitInfo,
+            )
+            pkginfo = PackagekitInfo()
     return pkginfo
 
=== modified file 'softwarecenter/db/update.py'
--- softwarecenter/db/update.py	2012-02-28 22:35:19 +0000
+++ softwarecenter/db/update.py	2012-03-15 04:06:19 +0000
@@ -36,15 +36,15 @@
 # py3 compat
 try:
     from configparser import RawConfigParser, NoOptionError
-    RawConfigParser # pyflakes
-    NoOptionError # pyflakes
+    RawConfigParser  # pyflakes
+    NoOptionError  # pyflakes
 except ImportError:
     from ConfigParser import RawConfigParser, NoOptionError
 
 # py3 compat
 try:
     import cPickle as pickle
-    pickle # pyflakes
+    pickle  # pyflakes
 except ImportError:
     import pickle
 
@@ -101,6 +101,7 @@
 # Enable Xapian's CJK tokenizer (see LP: #745243)
 os.environ['XAPIAN_CJK_NGRAM'] = '1'
 
+
 class AppInfoParserBase(object):
     """ base class for reading AppInfo meta-data """
 
@@ -108,8 +109,10 @@
 
     def get_desktop(self, key, translated=True):
         """ get a AppInfo entry for the given key """
+
     def has_option_desktop(self, key):
         """ return True if there is a given AppInfo info """
+
     def _get_desktop_list(self, key, split_str=";"):
         result = []
         try:
@@ -120,6 +123,7 @@
         except (NoOptionError, KeyError):
             pass
         return result
+
     def _apply_mapping(self, key):
         # strip away bogus prefixes
         if key.startswith("X-AppInstall-"):
@@ -127,12 +131,15 @@
         if key in self.MAPPING:
             return self.MAPPING[key]
         return key
+
     def get_desktop_categories(self):
         return self._get_desktop_list("Categories")
+
     def get_desktop_mimetypes(self):
         if not self.has_option_desktop("MimeType"):
             return []
         return self._get_desktop_list("MimeType")
+
     @property
     def desktopf(self):
         """ return the file that the AppInfo comes from """
@@ -142,29 +149,29 @@
     """ map the data we get from the software-center-agent """
 
     # map from requested key to sca_application attribute
-    MAPPING = { 'Name'       : 'name',
-                'Price'      : 'price',
-                'Package'    : 'package_name',
-                'Categories' : 'categories',
-                'Channel'    : 'channel',
-                'Signing-Key-Id' : 'signing_key_id',
-                'License'    : 'license',
-                'Date-Published' : 'date_published',
-                'PPA'        : 'archive_id',
-                'Screenshot-Url' : 'screenshot_url',
-                'Thumbnail-Url' : 'thumbnail_url',
-                'Video-Url' :  'video_embedded_html_url',
-                'Icon-Url'   : 'icon_url',
-                'Support-Url'   : 'support_url',
-                'Description' : 'Description',
-                'Comment' : 'Comment',
-                'Version' : 'version',
-                'Supported-Distros': 'series',
-                # tags are special, see _apply_exception
+    MAPPING = {'Name': 'name',
+               'Price': 'price',
+               'Package': 'package_name',
+               'Categories': 'categories',
+               'Channel': 'channel',
+               'Signing-Key-Id': 'signing_key_id',
+               'License': 'license',
+               'Date-Published': 'date_published',
+               'PPA': 'archive_id',
+               'Screenshot-Url': 'screenshot_url',
+               'Thumbnail-Url': 'thumbnail_url',
+               'Video-Url': 'video_embedded_html_url',
+               'Icon-Url': 'icon_url',
+               'Support-Url': 'support_url',
+               'Description': 'Description',
+               'Comment': 'Comment',
+               'Version': 'version',
+               'Supported-Distros': 'series',
+               # tags are special, see _apply_exception
               }
 
     # map from requested key to a static data element
-    STATIC_DATA = { 'Type' : 'Application',
+    STATIC_DATA = {'Type': 'Application',
                   }
 
     def __init__(self, sca_application):
@@ -179,19 +186,23 @@
         # we no longer keep thumbnail versions of screenshots on the server
         if (hasattr(self.sca_application, "screenshot_url") and
             not hasattr(self.sca_application, "thumbnail_url")):
-            self.sca_application.thumbnail_url = self.sca_application.screenshot_url
+            self.sca_application.thumbnail_url = \
+                self.sca_application.screenshot_url
         if hasattr(self.sca_application, "description"):
-            self.sca_application.Comment = self.sca_application.description.split("\n")[0].strip()
+            comment = self.sca_application.description.split("\n")[0].strip()
+            self.sca_application.Comment = comment
             self.sca_application.Description = "\n".join(
                 self.sca_application.description.split("\n")[1:]).strip()
 
         # debtags is send as a list, but we need it as a comma seperated string
-        self.sca_application.Tags = ",".join(getattr(self.sca_application, "debtags", []))
+        self.sca_application.Tags = ",".join(getattr(self.sca_application,
+            "debtags", []))
 
         # we only support a single video currently :/
         if hasattr(self.sca_application, "video_embedded_html_urls"):
             if self.sca_application.video_embedded_html_urls:
-                self.sca_application.video_embedded_html_url = self.sca_application.video_embedded_html_urls[0]
+                video_url = self.sca_application.video_embedded_html_urls[0]
+                self.sca_application.video_embedded_html_url = video_url
 
         # XXX 2012-01-16 bug=917109
         # We can remove these work-arounds once the above bug is fixed on
@@ -199,7 +210,8 @@
         # to make the parser happy. Note: available_apps api call includes
         # these already, it's just the apps with subscriptions_for_me which
         # don't currently.
-        self.sca_application.channel = AVAILABLE_FOR_PURCHASE_MAGIC_CHANNEL_NAME
+        self.sca_application.channel = \
+            AVAILABLE_FOR_PURCHASE_MAGIC_CHANNEL_NAME
         if not hasattr(self.sca_application, 'categories'):
             self.sca_application.categories = ""
 
@@ -207,16 +219,16 @@
         # attribute appropriately so that the channel-adding magic works
         if hasattr(self.sca_application, "archive_root"):
             u = urlparse(self.sca_application.archive_root)
-            if u.scheme == "http" and u.netloc ==  "archive.canonical.com":
+            if u.scheme == "http" and u.netloc == "archive.canonical.com":
                 distroseries = get_distro().get_codename()
                 self.sca_application.channel = "%s-partner" % distroseries
-            if u.scheme == "http" and u.netloc ==  "extras.ubuntu.com":
+            if u.scheme == "http" and u.netloc == "extras.ubuntu.com":
                 self.sca_application.channel = "ubuntu-extras"
-        
+
         # support multiple screenshots
         if hasattr(self.sca_application, "screenshot_urls"):
             # ensure to html-quote "," as this is also our seperator
-            s = ",".join([url.replace(",", "%2C") 
+            s = ",".join([url.replace(",", "%2C")
                           for url in self.sca_application.screenshot_urls])
             self.sca_application.screenshot_url = s
 
@@ -227,7 +239,8 @@
 
     def get_desktop_categories(self):
         try:
-            return ['DEPARTMENT:' + self.sca_application.department[-1]] + self._get_desktop_list("Categories")
+            return (['DEPARTMENT:' + self.sca_application.department[-1]] +
+                self._get_desktop_list("Categories"))
         except:
             return self._get_desktop_list("Categories")
 
@@ -251,17 +264,17 @@
             PistonResponseObject.from_dict(sca_subscription.application))
 
     SUBSCRIPTION_MAPPING = {
-        # this key can be used to get the original deb_line that the 
+        # this key can be used to get the original deb_line that the
         # server returns, it will be at the distroseries that was current
         # at purchase time
-        'Deb-Line-Orig' : 'deb_line',
+        'Deb-Line-Orig': 'deb_line',
         # this is what s-c will always use, the deb_line updated to the
         # current distroseries, note that you should ensure that the app
         # is not in state: PkgStates.PURCHASED_BUT_NOT_AVAILABLE_FOR_SERIES
-        'Deb-Line'   : 'deb_line',
-        'Purchased-Date' : 'purchase_date',
-        'License-Key' : 'license_key',
-        'License-Key-Path' : 'license_key_path',
+        'Deb-Line': 'deb_line',
+        'Purchased-Date': 'purchase_date',
+        'License-Key': 'license_key',
+        'License-Key-Path': 'license_key_path',
         }
 
     MAPPING = dict(
@@ -313,47 +326,52 @@
 
 class JsonTagSectionParser(AppInfoParserBase):
 
-    MAPPING = { 'Name'       : 'application_name',
-                'Comment'    : 'description',
-                'Price'      : 'price',
-                'Package'    : 'package_name',
-                'Categories' : 'categories',
+    MAPPING = {'Name': 'application_name',
+               'Comment': 'description',
+               'Price': 'price',
+               'Package': 'package_name',
+               'Categories': 'categories',
               }
 
     def __init__(self, tag_section, url):
         self.tag_section = tag_section
         self.url = url
+
     def get_desktop(self, key, translated=True):
         return self.tag_section[self._apply_mapping(key)]
+
     def has_option_desktop(self, key):
         return self._apply_mapping(key) in self.tag_section
+
     @property
     def desktopf(self):
         return self.url
 
+
 class AppStreamXMLParser(AppInfoParserBase):
 
-    MAPPING = { 'Name'       : 'name',
-                'Comment'    : 'summary',
-                'Package'    : 'pkgname',
-                'Categories' : 'appcategories',
-                'Keywords'   : 'keywords',
-                'MimeType'   : 'mimetypes',
-                'Icon'       : 'icon',
+    MAPPING = {'Name': 'name',
+               'Comment': 'summary',
+               'Package': 'pkgname',
+               'Categories': 'appcategories',
+               'Keywords': 'keywords',
+               'MimeType': 'mimetypes',
+               'Icon': 'icon',
               }
 
-    LISTS = { "appcategories" : "appcategory",
-              "keywords"  : "keyword",
-              "mimetypes" : "mimetype",
+    LISTS = {"appcategories": "appcategory",
+             "keywords": "keyword",
+             "mimetypes": "mimetype",
             }
 
     # map from requested key to a static data element
-    STATIC_DATA = { 'Type' : 'Application',
+    STATIC_DATA = {'Type': 'Application',
                   }
 
     def __init__(self, appinfo_xml, xmlfile):
         self.appinfo_xml = appinfo_xml
         self.xmlfile = xmlfile
+
     def get_desktop(self, key, translated=True):
         if key in self.STATIC_DATA:
             return self.STATIC_DATA[key]
@@ -362,14 +380,18 @@
             return self._parse_with_lists(key)
         else:
             return self._parse_value(key, translated)
+
     def get_desktop_categories(self):
         return self._get_desktop_list("Categories", split_str=',')
+
     def get_desktop_mimetypes(self):
         if not self.has_option_desktop("MimeType"):
             return []
         return self._get_desktop_list("MimeType", split_str=',')
+
     def _parse_value(self, key, translated):
-        locale = getdefaultlocale(('LANGUAGE','LANG','LC_CTYPE','LC_ALL'))[0]
+        locale = getdefaultlocale(('LANGUAGE', 'LANG', 'LC_CTYPE',
+            'LC_ALL'))[0]
         for child in self.appinfo_xml.iter(key):
             if translated:
                 if child.get("lang") == locale:
@@ -381,28 +403,31 @@
                 return child.text
         if translated:
             return self._parse_value(key, False)
-        else:
-            return None
+
     def _parse_with_lists(self, key):
-        l=[]
+        l = []
         for listroot in self.appinfo_xml.iter(key):
             for child in listroot.iter(self.LISTS[key]):
                 l.append(child.text)
         return ",".join(l)
+
     def has_option_desktop(self, key):
         if key in self.STATIC_DATA:
             return True
         key = self._apply_mapping(key)
         return not self.appinfo_xml.find(key) is None
+
     @property
     def desktopf(self):
         subelm = self.appinfo_xml.find("id")
         return subelm.text
 
+
 class DesktopTagSectionParser(AppInfoParserBase):
     def __init__(self, tag_section, tagfile):
         self.tag_section = tag_section
         self.tagfile = tagfile
+
     def get_desktop(self, key, translated=True):
         # strip away bogus prefixes
         if key.startswith("X-AppInstall-"):
@@ -422,7 +447,8 @@
         # then try the i18n version of the key (in [de_DE] or
         # [de]) but ignore errors and return the untranslated one then
         try:
-            locale = getdefaultlocale(('LANGUAGE','LANG','LC_CTYPE','LC_ALL'))[0]
+            locale = getdefaultlocale(('LANGUAGE', 'LANG', 'LC_CTYPE',
+                'LC_ALL'))[0]
             if locale:
                 if self.has_option_desktop("%s-%s" % (key, locale)):
                     return self.tag_section["%s-%s" % (key, locale)]
@@ -434,18 +460,22 @@
             pass
         # and then the untranslated field
         return self.tag_section[key]
+
     def has_option_desktop(self, key):
         # strip away bogus prefixes
         if key.startswith("X-AppInstall-"):
             key = key[len("X-AppInstall-"):]
         return key in self.tag_section
+
     @property
     def desktopf(self):
         return self.tagfile
 
+
 class DesktopConfigParser(RawConfigParser, AppInfoParserBase):
     " thin wrapper that is tailored for xdg Desktop files "
     DE = "Desktop Entry"
+
     def get_desktop(self, key, translated=True):
         " get generic option under 'Desktop Entry'"
         # never translate the pkgname
@@ -471,28 +501,34 @@
         # then try the i18n version of the key (in [de_DE] or
         # [de]) but ignore errors and return the untranslated one then
         try:
-            locale = getdefaultlocale(('LANGUAGE','LANG','LC_CTYPE','LC_ALL'))[0]
+            locale = getdefaultlocale(('LANGUAGE', 'LANG', 'LC_CTYPE',
+                'LC_ALL'))[0]
             if locale:
                 if self.has_option_desktop("%s[%s]" % (key, locale)):
                     return self.get(self.DE, "%s[%s]" % (key, locale))
                 if "_" in locale:
                     locale_short = locale.split("_")[0]
                     if self.has_option_desktop("%s[%s]" % (key, locale_short)):
-                        return self.get(self.DE, "%s[%s]" % (key, locale_short))
+                        return self.get(self.DE, "%s[%s]" %
+                            (key, locale_short))
         except ValueError:
             pass
         # and then the untranslated field
         return self.get(self.DE, key)
+
     def has_option_desktop(self, key):
         " test if there is the option under 'Desktop Entry'"
         return self.has_option(self.DE, key)
+
     def read(self, filename):
         self._filename = filename
         RawConfigParser.read(self, filename)
+
     @property
     def desktopf(self):
         return self._filename
 
+
 def ascii_upper(key):
     """Translate an ASCII string to uppercase
     in a locale-independent manner."""
@@ -500,13 +536,15 @@
                                          string.ascii_uppercase)
     return key.translate(ascii_trans_table)
 
+
 def index_name(doc, name, term_generator):
     """ index the name of the application """
     doc.add_value(XapianValues.APPNAME, name)
-    doc.add_term("AA"+name)
+    doc.add_term("AA" + name)
     w = globals()["WEIGHT_DESKTOP_NAME"]
     term_generator.index_text_without_positions(name, w)
 
+
 def update(db, cache, datadir=None):
     if not datadir:
         datadir = softwarecenter.paths.APP_INSTALL_DESKTOP_PATH
@@ -514,7 +552,9 @@
     update_from_var_lib_apt_lists(db, cache)
     # add db global meta-data
     LOG.debug("adding popcon_max_desktop '%s'" % popcon_max)
-    db.set_metadata("popcon_max_desktop", xapian.sortable_serialise(float(popcon_max)))
+    db.set_metadata("popcon_max_desktop",
+        xapian.sortable_serialise(float(popcon_max)))
+
 
 def update_from_json_string(db, cache, json_string, origin):
     """ index from a json string, should include origin url (free form string)
@@ -524,6 +564,7 @@
         index_app_info_from_parser(parser, db, cache)
     return True
 
+
 def update_from_var_lib_apt_lists(db, cache, listsdir=None):
     """ index the files in /var/lib/apt/lists/*AppInfo """
     try:
@@ -544,18 +585,21 @@
             index_app_info_from_parser(parser, db, cache)
     return True
 
+
 def update_from_single_appstream_file(db, cache, filename):
     from lxml import etree
 
     tree = etree.parse(open(filename))
     root = tree.getroot()
     if not root.tag == "applications":
-        LOG.error("failed to read '%s' expected Applications root tag" % filename)
+        LOG.error("failed to read '%s' expected Applications root tag" %
+            filename)
         return
     for appinfo in root.iter("application"):
         parser = AppStreamXMLParser(appinfo, filename)
         index_app_info_from_parser(parser, db, cache)
 
+
 def update_from_appstream_xml(db, cache, xmldir=None):
     if not xmldir:
         xmldir = softwarecenter.paths.APPSTREAM_XML_PATH
@@ -573,12 +617,13 @@
         update_from_single_appstream_file(db, cache, appstream_xml)
     return True
 
+
 def update_from_app_install_data(db, cache, datadir=None):
     """ index the desktop files in $datadir/desktop/*.desktop """
     if not datadir:
         datadir = softwarecenter.paths.APP_INSTALL_DESKTOP_PATH
     context = GObject.main_context_default()
-    for desktopf in glob(datadir+"/*.desktop"):
+    for desktopf in glob(datadir + "/*.desktop"):
         LOG.debug("processing %s" % desktopf)
         # process events
         while context.pending():
@@ -599,7 +644,9 @@
             LOG.warning(warning_text)
     return True
 
-def add_from_purchased_but_needs_reinstall_data(purchased_but_may_need_reinstall_list, db, cache):
+
+def add_from_purchased_but_needs_reinstall_data(
+    purchased_but_may_need_reinstall_list, db, cache):
     """Add application that have been purchased but may require a reinstall
 
     This adds a inmemory database to the main db with the special
@@ -632,9 +679,10 @@
     # add new in memory db to the main db
     db.add_database(db_purchased)
     # return a query
-    query = xapian.Query("AH"+PURCHASED_NEEDS_REINSTALL_MAGIC_CHANNEL_NAME)
+    query = xapian.Query("AH" + PURCHASED_NEEDS_REINSTALL_MAGIC_CHANNEL_NAME)
     return query
 
+
 def update_from_software_center_agent(db, cache, ignore_cache=False,
                                       include_sca_qa=False):
     """ update index based on the software-center-agent data """
@@ -644,6 +692,7 @@
         sca.available = available
         sca.good_data = True
         loop.quit()
+
     def _error_cb(sca, error):
         LOG.warn("error: %s" % error)
         sca.available = []
@@ -690,10 +739,12 @@
     # app name is the data
     if parser.has_option_desktop("X-Ubuntu-Software-Center-Name"):
         name = parser.get_desktop("X-Ubuntu-Software-Center-Name")
-        untranslated_name = parser.get_desktop("X-Ubuntu-Software-Center-Name", translated=False)
+        untranslated_name = parser.get_desktop("X-Ubuntu-Software-Center-Name",
+            translated=False)
     elif parser.has_option_desktop("X-GNOME-FullName"):
         name = parser.get_desktop("X-GNOME-FullName")
-        untranslated_name = parser.get_desktop("X-GNOME-FullName", translated=False)
+        untranslated_name = parser.get_desktop("X-GNOME-FullName",
+            translated=False)
     else:
         name = parser.get_desktop("Name")
         untranslated_name = parser.get_desktop("Name", translated=False)
@@ -713,16 +764,18 @@
         arches = parser.get_desktop("X-AppInstall-Architectures")
         doc.add_value(XapianValues.ARCHIVE_ARCH, arches)
         native_archs = get_current_arch() in arches.split(',')
-        foreign_archs = list(set(arches.split(',')) & set(get_foreign_architectures()))
-        if not (native_archs or foreign_archs): return
+        foreign_archs = list(set(arches.split(',')) &
+            set(get_foreign_architectures()))
+        if not (native_archs or foreign_archs):
+            return
         if not native_archs and foreign_archs:
             pkgname_extension = ':' + foreign_archs[0]
     # package name
     pkgname = parser.get_desktop("X-AppInstall-Package") + pkgname_extension
-    doc.add_term("AP"+pkgname)
+    doc.add_term("AP" + pkgname)
     if '-' in pkgname:
         # we need this to work around xapian oddness
-        doc.add_term(pkgname.replace('-','_'))
+        doc.add_term(pkgname.replace('-', '_'))
     doc.add_value(XapianValues.PKGNAME, pkgname)
     doc.add_value(XapianValues.DESKTOP_FILE, parser.desktopf)
     # display name
@@ -731,21 +784,21 @@
     # cataloged_times
     if "catalogedtime" in axi_values:
         if pkgname in cataloged_times:
-            doc.add_value(axi_values["catalogedtime"], 
+            doc.add_value(axi_values["catalogedtime"],
                           xapian.sortable_serialise(cataloged_times[pkgname]))
     # pocket (main, restricted, ...)
     if parser.has_option_desktop("X-AppInstall-Section"):
         archive_section = parser.get_desktop("X-AppInstall-Section")
-        doc.add_term("AS"+archive_section)
+        doc.add_term("AS" + archive_section)
         doc.add_value(XapianValues.ARCHIVE_SECTION, archive_section)
     # section (mail, base, ..)
     if pkgname in cache and cache[pkgname].candidate:
         section = cache[pkgname].section
-        doc.add_term("AE"+section)
+        doc.add_term("AE" + section)
     # channel (third party stuff)
     if parser.has_option_desktop("X-AppInstall-Channel"):
         archive_channel = parser.get_desktop("X-AppInstall-Channel")
-        doc.add_term("AH"+archive_channel)
+        doc.add_term("AH" + archive_channel)
         doc.add_value(XapianValues.ARCHIVE_CHANNEL, archive_channel)
     # signing key (third party)
     if parser.has_option_desktop("X-AppInstall-Signing-Key-Id"):
@@ -758,7 +811,7 @@
     # date published
     if parser.has_option_desktop("X-AppInstall-Date-Published"):
         date_published = parser.get_desktop("X-AppInstall-Date-Published")
-        if (date_published and 
+        if (date_published and
             re.match("\d+-\d+-\d+ \d+:\d+:\d+", date_published)):
             # strip the subseconds from the end of the published date string
             date_published = str(date_published).split(".")[0]
@@ -772,7 +825,7 @@
                 date_published_sec = time.mktime(
                                         time.strptime(date_published,
                                                       "%Y-%m-%d  %H:%M:%S"))
-                doc.add_value(axi_values["catalogedtime"], 
+                doc.add_value(axi_values["catalogedtime"],
                               xapian.sortable_serialise(date_published_sec))
     # purchased date
     if parser.has_option_desktop("X-AppInstall-Purchased-Date"):
@@ -798,7 +851,7 @@
             doc.add_value(XapianValues.ARCHIVE_PPA, archive_ppa)
             # add archive origin data here so that its available even if
             # the PPA is not (yet) enabled
-            doc.add_term("XOO"+"lp-ppa-%s" % archive_ppa.replace("/", "-"))
+            doc.add_term("XOO" + "lp-ppa-%s" % archive_ppa.replace("/", "-"))
     # screenshot (for third party)
     if parser.has_option_desktop("X-AppInstall-Screenshot-Url"):
         url = parser.get_desktop("X-AppInstall-Screenshot-Url")
@@ -836,15 +889,15 @@
         doc.add_value(XapianValues.ICON, icon)
     # write out categories
     for cat in parser.get_desktop_categories():
-        doc.add_term("AC"+cat.lower())
+        doc.add_term("AC" + cat.lower())
     categories_string = ";".join(parser.get_desktop_categories())
     doc.add_value(XapianValues.CATEGORIES, categories_string)
     for mime in parser.get_desktop_mimetypes():
-        doc.add_term("AM"+mime.lower())
+        doc.add_term("AM" + mime.lower())
     # get type (to distinguish between apps and packages
     if parser.has_option_desktop("Type"):
         type = parser.get_desktop("Type")
-        doc.add_term("AT"+type.lower())
+        doc.add_term("AT" + type.lower())
     # check gettext domain
     if parser.has_option_desktop("X-Ubuntu-Gettext-Domain"):
         domain = parser.get_desktop("X-Ubuntu-Gettext-Domain")
@@ -867,14 +920,14 @@
         tags = parser.get_desktop("X-AppInstall-Tags")
         if tags:
             for tag in tags.split(","):
-                doc.add_term("XT"+tag.strip())
+                doc.add_term("XT" + tag.strip())
         # ENFORCE region blacklist by not registering the app at all
         region = get_region_cached()
         if region:
             countrycode = region["countrycode"].lower()
             if "%s%s" % (REGION_BLACKLIST_TAG, countrycode) in tags:
                 LOG.info("skipping region restricted app: '%s'" % name)
-                return None
+                return
 
     # popcon
     # FIXME: popularity not only based on popcon but also
@@ -882,7 +935,7 @@
     if parser.has_option_desktop("X-AppInstall-Popcon"):
         popcon = float(parser.get_desktop("X-AppInstall-Popcon"))
         # sort_by_value uses string compare, so we need to pad here
-        doc.add_value(XapianValues.POPCON, 
+        doc.add_value(XapianValues.POPCON,
                       xapian.sortable_serialise(popcon))
         global popcon_max
         popcon_max = max(popcon_max, popcon)
@@ -922,7 +975,7 @@
         doc = make_doc_from_parser(parser, cache)
         if not doc:
             LOG.debug("make_doc_from_parser() returned '%s', ignoring" % doc)
-            return 
+            return
         term_generator.set_document(doc)
         name = doc.get_data()
 
@@ -935,10 +988,11 @@
 
         pkgname = doc.get_value(XapianValues.PKGNAME)
         # add packagename as meta-data too
-        term_generator.index_text_without_positions(pkgname, WEIGHT_APT_PKGNAME)
+        term_generator.index_text_without_positions(pkgname,
+            WEIGHT_APT_PKGNAME)
 
         # now add search data from the desktop file
-        for key in ["GenericName","Comment", "X-AppInstall-Description"]:
+        for key in ["GenericName", "Comment", "X-AppInstall-Description"]:
             if not parser.has_option_desktop(key):
                 continue
             s = parser.get_desktop(key)
@@ -954,15 +1008,17 @@
         # add data from the apt cache
         if pkgname in cache and cache[pkgname].candidate:
             s = cache[pkgname].candidate.summary
-            term_generator.index_text_without_positions(s, WEIGHT_APT_SUMMARY)
+            term_generator.index_text_without_positions(s,
+                WEIGHT_APT_SUMMARY)
             s = cache[pkgname].candidate.description
-            term_generator.index_text_without_positions(s, WEIGHT_APT_DESCRIPTION)
+            term_generator.index_text_without_positions(s,
+                WEIGHT_APT_DESCRIPTION)
             for origin in cache[pkgname].candidate.origins:
-                doc.add_term("XOA"+origin.archive)
-                doc.add_term("XOC"+origin.component)
-                doc.add_term("XOL"+origin.label)
-                doc.add_term("XOO"+origin.origin)
-                doc.add_term("XOS"+origin.site)
+                doc.add_term("XOA" + origin.archive)
+                doc.add_term("XOC" + origin.component)
+                doc.add_term("XOL" + origin.label)
+                doc.add_term("XOO" + origin.origin)
+                doc.add_term("XOS" + origin.site)
 
         # add our keywords (with high priority)
         keywords = None
@@ -973,16 +1029,18 @@
         if keywords:
             for s in keywords.split(";"):
                 if s:
-                    term_generator.index_text_without_positions(s, WEIGHT_DESKTOP_KEYWORD)
+                    term_generator.index_text_without_positions(s,
+                        WEIGHT_DESKTOP_KEYWORD)
         # now add it
         db.add_document(doc)
 
+
 def rebuild_database(pathname, debian_sources=True, appstream_sources=False):
     #cache = apt.Cache(memonly=True)
     cache = get_pkg_info()
     cache.open()
-    old_path = pathname+"_old"
-    rebuild_path = pathname+"_rb"
+    old_path = pathname + "_old"
+    rebuild_path = pathname + "_rb"
 
     if not os.path.exists(rebuild_path):
         try:
@@ -1000,7 +1058,8 @@
 
     #check if old unrequired version of db still exists on filesystem
     if os.path.exists(old_path):
-        LOG.warn("Existing xapian old db was not previously cleaned: '%s'." % old_path)
+        LOG.warn("Existing xapian old db was not previously cleaned: '%s'." %
+            old_path)
         if os.access(old_path, os.W_OK):
             #remove old unrequired db before beginning
             shutil.rmtree(old_path)
@@ -1009,7 +1068,6 @@
             LOG.warn("Please check you have the relevant permissions.")
             return False
 
-
     # write it
     db = xapian.WritableDatabase(rebuild_path, xapian.DB_CREATE_OR_OVERWRITE)
 
@@ -1017,7 +1075,8 @@
         update(db, cache)
     if appstream_sources:
         if os.path.exists('./data/app-stream/appdata.xml'):
-            update_from_appstream_xml(db, cache, './data/app-stream/appdata.xml');
+            update_from_appstream_xml(db, cache,
+                './data/app-stream/appdata.xml')
         else:
             update_from_appstream_xml(db, cache)
 
@@ -1038,5 +1097,6 @@
         shutil.rmtree(old_path)
         return True
     except:
-        LOG.warn("Cannot copy refreshed database to correct location: '%s'." % pathname)
+        LOG.warn("Cannot copy refreshed database to correct location: '%s'." %
+            pathname)
         return False
 
=== modified file 'softwarecenter/db/utils.py'
--- softwarecenter/db/utils.py	2012-02-17 14:23:58 +0000
+++ softwarecenter/db/utils.py	2012-03-15 04:06:19 +0000
@@ -18,18 +18,20 @@
 
 import xapian
 
+
 def get_query_for_pkgnames(pkgnames):
     """ return a xapian query that matches exactly the list of pkgnames """
     query = xapian.Query()
     for pkgname in pkgnames:
         query = xapian.Query(xapian.Query.OP_OR,
                              query,
-                             xapian.Query("XP"+pkgname))
+                             xapian.Query("XP" + pkgname))
         query = xapian.Query(xapian.Query.OP_OR,
                              query,
-                             xapian.Query("AP"+pkgname))
+                             xapian.Query("AP" + pkgname))
     return query
-    
+
+
 def get_installed_apps_list(db):
     """ return a list of installed applications """
     apps = set()
@@ -41,11 +43,12 @@
                 apps.add(db.get_application(doc))
     return apps
 
+
 def get_installed_package_list():
     """ return a set of all of the currently installed packages """
     from softwarecenter.db.pkginfo import get_pkg_info
     installed_pkgs = set()
-    cache=get_pkg_info()
+    cache = get_pkg_info()
     for pkg in cache:
         if pkg.is_installed:
             installed_pkgs.add(pkg.name)
 
=== modified file 'test/test_pep8.py'
--- test/test_pep8.py	2012-03-15 04:06:19 +0000
+++ test/test_pep8.py	2012-03-15 04:06:19 +0000
@@ -7,16 +7,15 @@
 setup_test_env()
 
 # Only test these two packages for now:
-import softwarecenter.db.pkginfo_impl
-import softwarecenter.ui.gtk3
-import softwarecenter.ui.qml
+import softwarecenter.db
+import softwarecenter.ui
 
 class PackagePep8TestCase(unittest.TestCase):
     maxDiff = None
-    packages = [softwarecenter.ui.qml,
-                softwarecenter.ui.gtk3,
-                softwarecenter.db.pkginfo_impl]
-    exclude = []
+    packages = [softwarecenter.ui,
+                softwarecenter.db]
+    exclude = ['history.py', 'enquire.py', 'debfile.py', 'database.py',
+        'categories.py', 'application.py', 'appfilter.py', '__init__.py']
 
     def message(self, text):
         self.errors.append(text)