apt, aptsources, doc: Update to use the new names.

7 files changed, 183 insertions, 181 deletions

diff --git a/apt/__init__.py b/apt/__init__.py
index 734b3240..41c0a30f 100644
--- a/apt/__init__.py
+++ b/apt/__init__.py
@@ -31,7 +31,9 @@ if apt_pkg._COMPAT_0_7:
 
 
 if apt_pkg._COMPAT_0_7:
-    from apt_pkg import SizeToStr, TimeToStr, VersionCompare
+    from apt_pkg import (size_to_str as SizeToStr,
+                         time_to_str as TimeToStr,
+                         version_compare as VersionCompare)
 
 # init the package system
 apt_pkg.init()
diff --git a/apt/cache.py b/apt/cache.py
index 60fd6553..56b32d45 100644
--- a/apt/cache.py
+++ b/apt/cache.py
@@ -52,16 +52,16 @@ class Cache(object):
         self._callbacks = {}
         if memonly:
             # force apt to build its caches in memory
-            apt_pkg.Config.Set("Dir::Cache::pkgcache", "")
+            apt_pkg.config.set("Dir::Cache::pkgcache", "")
         if rootdir:
             if os.path.exists(rootdir+"/etc/apt/apt.conf"):
-                apt_pkg.ReadConfigFile(apt_pkg.Config,
+                apt_pkg.read_config_file(apt_pkg.config,
                                        rootdir + "/etc/apt/apt.conf")
             if os.path.isdir(rootdir+"/etc/apt/apt.conf.d"):
-                apt_pkg.ReadConfigDir(apt_pkg.Config,
+                apt_pkg.read_config_dir(apt_pkg.config,
                                       rootdir + "/etc/apt/apt.conf.d")
-            apt_pkg.Config.Set("Dir", rootdir)
-            apt_pkg.Config.Set("Dir::State::status",
+            apt_pkg.config.set("Dir", rootdir)
+            apt_pkg.config.set("Dir::State::status",
                                rootdir + "/var/lib/dpkg/status")
         self.open(progress)
 
@@ -82,20 +82,20 @@ class Cache(object):
         self._depcache = apt_pkg.DepCache(self._cache)
         self._records = apt_pkg.PackageRecords(self._cache)
         self._list = apt_pkg.SourceList()
-        self._list.ReadMainList()
+        self._list.read_main_list()
         self._set = set()
         self._weakref = weakref.WeakValueDictionary()
 
         progress.Op = "Building data structures"
         i=last=0
-        size=len(self._cache.Packages)
-        for pkg in self._cache.Packages:
+        size=len(self._cache.packages)
+        for pkg in self._cache.packages:
             if progress is not None and last+100 < i:
                 progress.update(i/float(size)*100)
                 last=i
             # drop stuff with no versions (cruft)
-            if len(pkg.VersionList) > 0:
-                self._set.add(pkg.Name)
+            if len(pkg.version_list) > 0:
+                self._set.add(pkg.name)
 
             i += 1
 
@@ -148,7 +148,7 @@ class Cache(object):
         default value is False.
         """
         self.cache_pre_change()
-        self._depcache.Upgrade(dist_upgrade)
+        self._depcache.upgrade(dist_upgrade)
         self.cache_post_change()
 
     @property
@@ -156,13 +156,13 @@ class Cache(object):
         """Get the size of the packages that are required to download."""
         pm = apt_pkg.PackageManager(self._depcache)
         fetcher = apt_pkg.Acquire()
-        pm.GetArchives(fetcher, self._list, self._records)
-        return fetcher.FetchNeeded
+        pm.get_archives(fetcher, self._list, self._records)
+        return fetcher.fetch_needed
 
     @property
     def required_space(self):
         """Get the size of the additional required space on the fs."""
-        return self._depcache.UsrSize
+        return self._depcache.usr_size
 
     @property
     def req_reinstall_pkgs(self):
@@ -170,31 +170,31 @@ class Cache(object):
         reqreinst = set()
         for pkg in self:
             if (not pkg.candidate.downloadable and
-                (pkg._pkg.InstState == apt_pkg.InstStateReInstReq or
-                 pkg._pkg.InstState == apt_pkg.InstStateHoldReInstReq)):
+                (pkg._pkg.inst_state == apt_pkg.INSTSTATE_RE_INST_REQ or
+                 pkg._pkg.inst_state == apt_pkg.INSTSTATE_HOLD_RE_INST_REQ)):
                 reqreinst.add(pkg.name)
         return reqreinst
 
     def _run_fetcher(self, fetcher):
         # do the actual fetching
-        res = fetcher.Run()
+        res = fetcher.run()
 
         # now check the result (this is the code from apt-get.cc)
         failed = False
         transient = False
         err_msg = ""
-        for item in fetcher.Items:
-            if item.Status == item.StatDone:
+        for item in fetcher.items:
+            if item.status == item.stat_done:
                 continue
-            if item.StatIdle:
+            if item.stat_idle:
                 transient = True
                 continue
-            err_msg += "Failed to fetch %s %s\n" % (item.DescURI,
-                                                   item.ErrorText)
+            err_msg += "Failed to fetch %s %s\n" % (item.desc_uri,
+                                                   item.error_text)
             failed = True
 
         # we raise a exception if the download failed or it was cancelt
-        if res == fetcher.ResultCancelled:
+        if res == fetcher.result_cancelled:
             raise FetchCancelledException(err_msg)
         elif failed:
             raise FetchFailedException(err_msg)
@@ -204,14 +204,14 @@ class Cache(object):
         """ fetch the needed archives """
 
         # get lock
-        lockfile = apt_pkg.Config.FindDir("Dir::Cache::Archives") + "lock"
-        lock = apt_pkg.GetLock(lockfile)
+        lockfile = apt_pkg.config.find_dir("Dir::Cache::Archives") + "lock"
+        lock = apt_pkg.get_lock(lockfile)
         if lock < 0:
             raise LockFailedException("Failed to lock %s" % lockfile)
 
         try:
             # this may as well throw a SystemError exception
-            if not pm.GetArchives(fetcher, self._list, self._records):
+            if not pm.get_archives(fetcher, self._list, self._records):
                 return False
             # now run the fetcher, throw exception if something fails to be
             # fetched
@@ -222,7 +222,7 @@ class Cache(object):
     def is_virtual_package(self, pkgname):
         """Return whether the package is a virtual package."""
         pkg = self._cache[pkgname]
-        return bool(pkg.ProvidesList and not pkg.VersionList)
+        return bool(pkg.provides_list and not pkg.version_list)
 
     def get_providing_packages(self, virtual):
         """
@@ -232,15 +232,15 @@ class Cache(object):
         providers = []
         try:
             vp = self._cache[virtual]
-            if len(vp.VersionList) != 0:
+            if len(vp.version_list) != 0:
                 return providers
         except KeyError:
             return providers
         for pkg in self:
-            v = self._depcache.GetCandidateVer(pkg._pkg)
+            v = self._depcache.get_candidate_ver(pkg._pkg)
             if v is None:
                 continue
-            for p in v.ProvidesList:
+            for p in v.provides_list:
                 if virtual == p[0]:
                     # we found a pkg that provides this virtual pkg
                     providers.append(pkg)
@@ -254,15 +254,15 @@ class Cache(object):
         apt.progress.FetchProgress, the default is apt.progress.FetchProgress()
         .
         """
-        lockfile = apt_pkg.Config.FindDir("Dir::State::Lists") + "lock"
-        lock = apt_pkg.GetLock(lockfile)
+        lockfile = apt_pkg.config.find_dir("Dir::State::Lists") + "lock"
+        lock = apt_pkg.get_lock(lockfile)
         if lock < 0:
             raise LockFailedException("Failed to lock %s" % lockfile)
 
         try:
             if fetch_progress is None:
                 fetch_progress = apt.progress.FetchProgress()
-            return self._cache.Update(fetch_progress, self._list)
+            return self._cache.update(fetch_progress, self._list)
         finally:
             os.close(lock)
 
@@ -317,17 +317,17 @@ class Cache(object):
 
             # then install
             res = self.install_archives(pm, install_progress)
-            if res == pm.ResultCompleted:
+            if res == pm.result_completed:
                 break
-            if res == pm.ResultFailed:
+            if res == pm.result_failed:
                 raise SystemError("installArchives() failed")
             # reload the fetcher for media swaping
-            fetcher.Shutdown()
-        return (res == pm.ResultCompleted)
+            fetcher.shutdown()
+        return (res == pm.result_completed)
 
     def clear(self):
         """ Unmark all changes """
-        self._depcache.Init()
+        self._depcache.init()
 
     # cache changes
 
@@ -493,7 +493,7 @@ def _test():
     for dir in ["/tmp/pytest", "/tmp/pytest/partial"]:
         if not os.path.exists(dir):
             os.mkdir(dir)
-    apt_pkg.Config.Set("Dir::Cache::Archives", "/tmp/pytest")
+    apt_pkg.config.set("Dir::Cache::Archives", "/tmp/pytest")
     pm = apt_pkg.PackageManager(cache._depcache)
     fetcher = apt_pkg.Acquire(apt.progress.TextFetchProgress())
     cache._fetch_archives(fetcher, pm)
diff --git a/apt/cdrom.py b/apt/cdrom.py
index b9625ebf..a98b5d99 100644
--- a/apt/cdrom.py
+++ b/apt/cdrom.py
@@ -52,20 +52,20 @@ class Cdrom(object):
             self._progress = progress
         # see if we have a alternative mountpoint
         if mountpoint is not None:
-            apt_pkg.Config.Set("Acquire::cdrom::mount", mountpoint)
+            apt_pkg.config.set("Acquire::cdrom::mount", mountpoint)
         # do not mess with mount points by default
         if nomount:
-            apt_pkg.Config.Set("APT::CDROM::NoMount", "true")
+            apt_pkg.config.set("APT::CDROM::NoMount", "true")
         else:
-            apt_pkg.Config.Set("APT::CDROM::NoMount", "false")
+            apt_pkg.config.set("APT::CDROM::NoMount", "false")
 
     def add(self):
         """Add cdrom to the sources.list."""
-        return self._cdrom.Add(self._progress)
+        return self._cdrom.add(self._progress)
 
     def ident(self):
         """Identify the cdrom."""
-        (res, ident) = self._cdrom.Ident(self._progress)
+        (res, ident) = self._cdrom.ident(self._progress)
         if res:
             return ident
 
@@ -77,8 +77,8 @@ class Cdrom(object):
             # FIXME: throw exception instead
             return False
         # Get a list of files
-        src = glob.glob(apt_pkg.Config.FindDir("Dir::Etc::sourceparts") + '*')
-        src.append(apt_pkg.Config.FindFile("Dir::Etc::sourcelist"))
+        src = glob.glob(apt_pkg.config.find_dir("Dir::Etc::sourceparts") + '*')
+        src.append(apt_pkg.config.find_file("Dir::Etc::sourcelist"))
         # Check each file
         for fname in src:
             for line in open(fname):
diff --git a/apt/debfile.py b/apt/debfile.py
index 6e4adb39..84bbe3ab 100644
--- a/apt/debfile.py
+++ b/apt/debfile.py
@@ -52,11 +52,11 @@ class DebPackage(object):
     def open(self, filename):
         " open given debfile "
         self.filename = filename
-        if not apt_inst.arCheckMember(open(self.filename), "debian-binary"):
+        if not apt_inst.ar_check_member(open(self.filename), "debian-binary"):
             raise NoDebArchiveException(_("This is not a valid DEB archive, "
                                           "missing '%s' member" %
                                           "debian-binary"))
-        control = apt_inst.debExtractControl(open(self.filename))
+        control = apt_inst.deb_extract_control(open(self.filename))
         self._sections = apt_pkg.TagSection(control)
         self.pkgname = self._sections["Package"]
 
@@ -72,9 +72,9 @@ class DebPackage(object):
             files.append(name)
 
         for member in self._supported_data_members:
-            if apt_inst.arCheckMember(open(self.filename), member):
+            if apt_inst.ar_check_member(open(self.filename), member):
                 try:
-                    apt_inst.debExtract(open(self.filename), extract_cb,
+                    apt_inst.deb_extract(open(self.filename), extract_cb,
                                         member)
                     break
                 except SystemError:
@@ -106,7 +106,7 @@ class DebPackage(object):
                 continue
 
             inst = self._cache[depname].installed
-            if inst is not None and apt_pkg.CheckDep(inst.version, oper, ver):
+            if inst is not None and apt_pkg.check_dep(inst.version, oper, ver):
                 return True
         return False
 
@@ -129,10 +129,10 @@ class DebPackage(object):
             # now check if we can satisfy the deps with the candidate(s)
             # in the cache
             pkg = self._cache[depname]
-            cand = self._cache._depcache.GetCandidateVer(pkg._pkg)
+            cand = self._cache._depcache.get_candidate_ver(pkg._pkg)
             if not cand:
                 continue
-            if not apt_pkg.CheckDep(cand.VerStr, oper, ver):
+            if not apt_pkg.check_dep(cand.ver_str, oper, ver):
                 continue
 
             # check if we need to install it
@@ -168,7 +168,7 @@ class DebPackage(object):
         #print "ver: %s" % ver
         #print "pkgver: %s " % pkgver
         #print "oper: %s " % oper
-        if (apt_pkg.CheckDep(pkgver, oper, ver) and not
+        if (apt_pkg.check_dep(pkgver, oper, ver) and not
             self.replaces_real_pkg(pkgname, oper, ver)):
             self._failure_string += _("Conflicts with the installed package "
                                      "'%s'" % pkg.name)
@@ -211,7 +211,7 @@ class DebPackage(object):
         """List of package names conflicting with this package."""
         key = "Conflicts"
         try:
-            return apt_pkg.ParseDepends(self._sections[key])
+            return apt_pkg.parse_depends(self._sections[key])
         except KeyError:
             return []
 
@@ -222,7 +222,7 @@ class DebPackage(object):
         # find depends
         for key in "Depends", "PreDepends":
             try:
-                depends.extend(apt_pkg.ParseDepends(self._sections[key]))
+                depends.extend(apt_pkg.parse_depends(self._sections[key]))
             except KeyError:
                 pass
         return depends
@@ -232,7 +232,7 @@ class DebPackage(object):
         """List of virtual packages which are provided by this package."""
         key = "Provides"
         try:
-            return apt_pkg.ParseDepends(self._sections[key])
+            return apt_pkg.parse_depends(self._sections[key])
         except KeyError:
             return []
 
@@ -241,7 +241,7 @@ class DebPackage(object):
         """List of packages which are replaced by this package."""
         key = "Replaces"
         try:
-            return apt_pkg.ParseDepends(self._sections[key])
+            return apt_pkg.parse_depends(self._sections[key])
         except KeyError:
             return []
 
@@ -261,7 +261,7 @@ class DebPackage(object):
             pkgver = None
         for or_group in self.replaces:
             for (name, ver, oper) in or_group:
-                if (name == pkgname and apt_pkg.CheckDep(pkgver, oper, ver)):
+                if (name == pkgname and apt_pkg.check_dep(pkgver, oper, ver)):
                     self._dbg(3, "we have a replaces in our package for the "
                                  "conflict against '%s'" % (pkgname))
                     return True
@@ -298,7 +298,7 @@ class DebPackage(object):
             else:
                 cachever = self._cache[pkgname].candidate.version
             if cachever is not None:
-                cmp = apt_pkg.VersionCompare(cachever, debver)
+                cmp = apt_pkg.version_compare(cachever, debver)
                 self._dbg(1, "CompareVersion(debver,instver): %s" % cmp)
                 if cmp == 0:
                     return VERSION_SAME
@@ -310,11 +310,11 @@ class DebPackage(object):
 
     def check(self):
         """Check if the package is installable."""
-        self._dbg(3, "checkDepends")
+        self._dbg(3, "check_depends")
 
         # check arch
         arch = self._sections["Architecture"]
-        if  arch != "all" and arch != apt_pkg.Config.Find("APT::Architecture"):
+        if  arch != "all" and arch != apt_pkg.config.find("APT::Architecture"):
             self._dbg(1, "ERROR: Wrong architecture dude!")
             self._failure_string = _("Wrong architecture '%s'" % arch)
             return False
@@ -341,7 +341,7 @@ class DebPackage(object):
         if not self.check_conflicts():
             return False
 
-        if self._cache._depcache.BrokenCount > 0:
+        if self._cache._depcache.broken_count > 0:
             self._failure_string = _("Failed to satisfy all dependencies "
                                     "(broken cache)")
             # clean the cache again
@@ -351,7 +351,7 @@ class DebPackage(object):
 
     def satisfy_depends_str(self, dependsstr):
         """Satisfy the dependencies in the given string."""
-        return self._satisfy_depends(apt_pkg.ParseDepends(dependsstr))
+        return self._satisfy_depends(apt_pkg.parse_depends(dependsstr))
 
     def _satisfy_depends(self, depends):
         """Satisfy the dependencies."""
@@ -459,17 +459,17 @@ class DscSrcPackage(DebPackage):
 
         fobj = open(file)
         tagfile = apt_pkg.TagFile(fobj)
-        sec = tagfile.Section
+        sec = tagfile.section
         try:
-            while tagfile.Step() == 1:
+            while tagfile.step() == 1:
                 for tag in depends_tags:
                     if not tag in sec:
                         continue
-                    self._depends.extend(apt_pkg.ParseSrcDepends(sec[tag]))
+                    self._depends.extend(apt_pkg.parse_src_depends(sec[tag]))
                 for tag in conflicts_tags:
                     if not tag in sec:
                         continue
-                    self._conflicts.extend(apt_pkg.ParseSrcDepends(sec[tag]))
+                    self._conflicts.extend(apt_pkg.parse_src_depends(sec[tag]))
                 if 'Source' in sec:
                     self.pkgname = sec['Source']
                 if 'Binary' in sec:
@@ -490,7 +490,7 @@ class DscSrcPackage(DebPackage):
         """Check if the package is installable.."""
         if not self.check_conflicts():
             for pkgname in self._installed_conflicts:
-                if self._cache[pkgname]._pkg.Essential:
+                if self._cache[pkgname]._pkg.essential:
                     raise Exception(_("An essential package would be removed"))
                 self._cache[pkgname].mark_delete()
         # FIXME: a additional run of the checkConflicts()
@@ -525,13 +525,13 @@ def _test():
     print ret
 
     #s = DscSrcPackage(cache, "../tests/3ddesktop_0.2.9-6.dsc")
-    #s.checkDep()
+    #s.check_dep()
     #print "Missing deps: ",s.missingDeps
     #print "Print required changes: ", s.requiredChanges
 
     s = DscSrcPackage(cache=cache)
     d = "libc6 (>= 2.3.2), libaio (>= 0.3.96) | libaio1 (>= 0.3.96)"
-    print s._satisfy_depends(apt_pkg.ParseDepends(d))
+    print s._satisfy_depends(apt_pkg.parse_depends(d))
 
 if __name__ == "__main__":
     _test()
diff --git a/apt/package.py b/apt/package.py
index 3dbdf058..a24486e1 100644
--- a/apt/package.py
+++ b/apt/package.py
@@ -130,15 +130,15 @@ class Origin(object):
     """
 
     def __init__(self, pkg, packagefile):
-        self.archive = packagefile.Archive
-        self.component = packagefile.Component
-        self.label = packagefile.Label
-        self.origin = packagefile.Origin
-        self.site = packagefile.Site
-        self.not_automatic = packagefile.NotAutomatic
+        self.archive = packagefile.archive
+        self.component = packagefile.component
+        self.label = packagefile.label
+        self.origin = packagefile.origin
+        self.site = packagefile.site
+        self.not_automatic = packagefile.not_automatic
         # check the trust
-        indexfile = pkg._pcache._list.FindIndex(packagefile)
-        if indexfile and indexfile.IsTrusted:
+        indexfile = pkg._pcache._list.find_index(packagefile)
+        if indexfile and indexfile.is_trusted:
             self.trusted = True
         else:
             self.trusted = False
@@ -206,19 +206,19 @@ class Version(object):
         self._cand = cand
 
     def __eq__(self, other):
-        return self._cand.ID == other._cand.ID
+        return self._cand.id == other._cand.id
 
     def __gt__(self, other):
-        return apt_pkg.VersionCompare(self.version, other.version) > 0
+        return apt_pkg.version_compare(self.version, other.version) > 0
 
     def __lt__(self, other):
-        return apt_pkg.VersionCompare(self.version, other.version) < 0
+        return apt_pkg.version_compare(self.version, other.version) < 0
 
     def __ne__(self, other):
         return not self.__eq__(other)
 
     def __hash__(self):
-        return self._cand.Hash
+        return self._cand.hash
 
     def __repr__(self):
         return '<Version: package:%r version:%r>' % (self.package.name,
@@ -227,60 +227,60 @@ class Version(object):
     @property
     def _records(self):
         """Internal helper that moves the Records to the right position."""
-        if self.package._pcache._records.Lookup(self._cand.FileList[0]):
+        if self.package._pcache._records.lookup(self._cand.file_list[0]):
             return self.package._pcache._records
 
     @property
     def _translated_records(self):
         """Internal helper to get the translated description."""
-        desc_iter = self._cand.TranslatedDescription
-        self.package._pcache._records.Lookup(desc_iter.FileList.pop(0))
+        desc_iter = self._cand.translated_description
+        self.package._pcache._records.lookup(desc_iter.file_list.pop(0))
         return self.package._pcache._records
 
     @property
     def installed_size(self):
         """Return the size of the package when installed."""
-        return self._cand.InstalledSize
+        return self._cand.installed_size
 
     @property
     def homepage(self):
         """Return the homepage for the package."""
-        return self._records.Homepage
+        return self._records.homepage
 
     @property
     def size(self):
         """Return the size of the package."""
-        return self._cand.Size
+        return self._cand.size
 
     @property
     def architecture(self):
         """Return the architecture of the package version."""
-        return self._cand.Arch
+        return self._cand.arch
 
     @property
     def downloadable(self):
         """Return whether the version of the package is downloadable."""
-        return bool(self._cand.Downloadable)
+        return bool(self._cand.downloadable)
 
     @property
     def version(self):
         """Return the version as a string."""
-        return self._cand.VerStr
+        return self._cand.ver_str
 
     @property
     def summary(self):
         """Return the short description (one line summary)."""
-        return self._translated_records.ShortDesc
+        return self._translated_records.short_desc
 
     @property
     def raw_description(self):
         """return the long description (raw)."""
-        return self._records.LongDesc
+        return self._records.long_desc
 
     @property
     def section(self):
         """Return the section of the package."""
-        return self._cand.Section
+        return self._cand.section
 
     @property
     def description(self):
@@ -292,7 +292,7 @@ class Version(object):
         for more information.
         """
         desc = ''
-        dsc = self._translated_records.LongDesc
+        dsc = self._translated_records.long_desc
         try:
             if not isinstance(dsc, unicode):
                 # Only convert where needed (i.e. Python 2.X)
@@ -333,32 +333,32 @@ class Version(object):
     def source_name(self):
         """Return the name of the source package."""
         try:
-            return self._records.SourcePkg or self.package.name
+            return self._records.source_pkg or self.package.name
         except IndexError:
             return self.package.name
 
     @property
     def priority(self):
         """Return the priority of the package, as string."""
-        return self._cand.PriorityStr
+        return self._cand.priority_str
 
     @property
     def record(self):
         """Return a Record() object for this version."""
-        return Record(self._records.Record)
+        return Record(self._records.record)
 
     @property
     def dependencies(self):
         """Return the dependencies of the package version."""
         depends_list = []
-        depends = self._cand.DependsList
+        depends = self._cand.depends_list
         for t in ["PreDepends", "Depends"]:
             try:
                 for dep_ver_list in depends[t]:
                     base_deps = []
                     for dep_or in dep_ver_list:
-                        base_deps.append(BaseDependency(dep_or.TargetPkg.Name,
-                                        dep_or.CompType, dep_or.TargetVer,
+                        base_deps.append(BaseDependency(dep_or.target_pkg.name,
+                                        dep_or.comp_type, dep_or.target_ver,
                                         (t == "PreDepends")))
                     depends_list.append(Dependency(base_deps))
             except KeyError:
@@ -369,7 +369,7 @@ class Version(object):
     def origins(self):
         """Return a list of origins for the package version."""
         origins = []
-        for (packagefile, index) in self._cand.FileList:
+        for (packagefile, index) in self._cand.file_list:
             origins.append(Origin(self.package, packagefile))
         return origins
 
@@ -379,7 +379,7 @@ class Version(object):
 
         .. versionadded:: 0.7.10
         """
-        return self._records.FileName
+        return self._records.file_name
 
     @property
     def md5(self):
@@ -387,7 +387,7 @@ class Version(object):
 
         .. versionadded:: 0.7.10
         """
-        return self._records.MD5Hash
+        return self._records.md5_hash
 
     @property
     def sha1(self):
@@ -395,7 +395,7 @@ class Version(object):
 
         .. versionadded:: 0.7.10
         """
-        return self._records.SHA1Hash
+        return self._records.sha1_hash
 
     @property
     def sha256(self):
@@ -403,17 +403,17 @@ class Version(object):
 
         .. versionadded:: 0.7.10
         """
-        return self._records.SHA256Hash
+        return self._records.sha256_hash
 
     def _uris(self):
         """Return an iterator over all available urls.
 
         .. versionadded:: 0.7.10
         """
-        for (packagefile, index) in self._cand.FileList:
-            indexfile = self.package._pcache._list.FindIndex(packagefile)
+        for (packagefile, index) in self._cand.file_list:
+            indexfile = self.package._pcache._list.find_index(packagefile)
             if indexfile:
-                yield indexfile.ArchiveURI(self._records.FileName)
+                yield indexfile.archive_uri(self._records.file_name)
 
     @property
     def uris(self):
@@ -443,19 +443,19 @@ class Version(object):
 
         .. versionadded:: 0.7.10
         """
-        base = os.path.basename(self._records.FileName)
+        base = os.path.basename(self._records.file_name)
         destfile = os.path.join(destdir, base)
-        if _file_is_same(destfile, self.size, self._records.MD5Hash):
+        if _file_is_same(destfile, self.size, self._records.md5_hash):
             print 'Ignoring already existing file:', destfile
             return
         acq = apt_pkg.Acquire(progress or apt.progress.TextFetchProgress())
-        apt_pkg.AcquireFile(acq, self.uri, self._records.MD5Hash, self.size,
-                              base, destfile=destfile)
-        acq.Run()
-        for item in acq.Items:
-            if item.Status != item.StatDone:
+        apt_pkg.AcquireFile(acq, self.uri, self._records.md5_hash, self.size,
+                              base, dest_file=destfile)
+        acq.run()
+        for item in acq.items:
+            if item.status != item.stat_done:
                 raise FetchError("The item %r could not be fetched: %s" %
-                                    (item.DestFile, item.ErrorText))
+                                    (item.dest_file, item.error_text))
         return os.path.abspath(destfile)
 
     def fetch_source(self, destdir="", progress=None, unpack=True):
@@ -478,13 +478,13 @@ class Version(object):
         acq = apt_pkg.Acquire(progress or apt.progress.TextFetchProgress())
 
         dsc = None
-        src.Lookup(self.package.name)
+        src.lookup(self.package.name)
         try:
-            while self.version != src.Version:
-                src.Lookup(self.package.name)
+            while self.version != src.version:
+                src.lookup(self.package.name)
         except AttributeError:
             raise ValueError("No source for %r" % self)
-        for md5, size, path, type in src.Files:
+        for md5, size, path, type in src.files:
             base = os.path.basename(path)
             destfile = os.path.join(destdir, base)
             if type == 'dsc':
@@ -497,17 +497,17 @@ class Version(object):
                         continue
                 finally:
                     fobj.close()
-            apt_pkg.AcquireFile(acq, src.Index.ArchiveURI(path), md5, size,
-                                  base, destfile=destfile)
-        acq.Run()
+            apt_pkg.AcquireFile(acq, src.index.archive_uri(path), md5, size,
+                                  base, dest_file=destfile)
+        acq.run()
 
-        for item in acq.Items:
-            if item.Status != item.StatDone:
+        for item in acq.items:
+            if item.status != item.stat_done:
                 raise FetchError("The item %r could not be fetched: %s" %
-                                    (item.DestFile, item.ErrorText))
+                                    (item.dest_file, item.error_text))
 
         if unpack:
-            outdir = src.Package + '-' + apt_pkg.UpstreamVersion(src.Version)
+            outdir = src.package + '-' + apt_pkg.upstream_version(src.version)
             outdir = os.path.join(destdir, outdir)
             subprocess.check_call(["dpkg-source", "-x", dsc, outdir])
             return os.path.abspath(outdir)
@@ -530,7 +530,7 @@ class Package(object):
         self._changelog = ""            # Cached changelog
 
     def __repr__(self):
-        return '<Package: name:%r id:%r>' % (self._pkg.Name, self._pkg.ID)
+        return '<Package: name:%r id:%r>' % (self._pkg.name, self._pkg.id)
 
     def candidate(self):
         """Return the candidate version of the package.
@@ -541,14 +541,14 @@ class Package(object):
 
         .. versionadded:: 0.7.9
         """
-        cand = self._pcache._depcache.GetCandidateVer(self._pkg)
+        cand = self._pcache._depcache.get_candidate_ver(self._pkg)
         if cand is not None:
             return Version(self, cand)
 
     def __set_candidate(self, version):
         """Set the candidate version of the package."""
         self._pcache.cache_pre_change()
-        self._pcache._depcache.SetCandidateVer(self._pkg, version._cand)
+        self._pcache._depcache.set_candidate_ver(self._pkg, version._cand)
         self._pcache.cache_post_change()
 
     candidate = property(candidate, __set_candidate)
@@ -559,26 +559,26 @@ class Package(object):
 
         .. versionadded:: 0.7.9
         """
-        if self._pkg.CurrentVer is not None:
-            return Version(self, self._pkg.CurrentVer)
+        if self._pkg.current_ver is not None:
+            return Version(self, self._pkg.current_ver)
 
     @property
     def name(self):
         """Return the name of the package."""
-        return self._pkg.Name
+        return self._pkg.name
 
     @property
     def id(self):
         """Return a uniq ID for the package.
 
         This can be used eg. to store additional information about the pkg."""
-        return self._pkg.ID
+        return self._pkg.id
 
     def __hash__(self):
         """Return the hash of the object.
 
         This returns the same value as ID, which is unique."""
-        return self._pkg.ID
+        return self._pkg.id
 
     @DeprecatedProperty
     def installedVersion(self): #pylint: disable-msg=C0103
@@ -641,12 +641,12 @@ class Package(object):
         .. deprecated:: 0.7.9
         """
         try:
-            return self.candidate._records.SourcePkg or self._pkg.Name
+            return self.candidate._records.source_pkg or self._pkg.name
         except AttributeError:
             try:
-                return self.installed._records.SourcePkg or self._pkg.Name
+                return self.installed._records.source_pkg or self._pkg.name
             except AttributeError:
-                return self._pkg.Name
+                return self._pkg.name
 
     @DeprecatedProperty
     def homepage(self):
@@ -659,7 +659,7 @@ class Package(object):
     @property
     def section(self):
         """Return the section of the package."""
-        return self._pkg.Section
+        return self._pkg.section
 
     @DeprecatedProperty
     def priority(self):
@@ -724,43 +724,43 @@ class Package(object):
     @property
     def marked_install(self):
         """Return ``True`` if the package is marked for install."""
-        return self._pcache._depcache.MarkedInstall(self._pkg)
+        return self._pcache._depcache.marked_install(self._pkg)
 
     @property
     def marked_upgrade(self):
         """Return ``True`` if the package is marked for upgrade."""
-        return self._pcache._depcache.MarkedUpgrade(self._pkg)
+        return self._pcache._depcache.marked_upgrade(self._pkg)
 
     @property
     def marked_delete(self):
         """Return ``True`` if the package is marked for delete."""
-        return self._pcache._depcache.MarkedDelete(self._pkg)
+        return self._pcache._depcache.marked_delete(self._pkg)
 
     @property
     def marked_keep(self):
         """Return ``True`` if the package is marked for keep."""
-        return self._pcache._depcache.MarkedKeep(self._pkg)
+        return self._pcache._depcache.marked_keep(self._pkg)
 
     @property
     def marked_downgrade(self):
         """ Package is marked for downgrade """
-        return self._pcache._depcache.MarkedDowngrade(self._pkg)
+        return self._pcache._depcache.marked_downgrade(self._pkg)
 
     @property
     def marked_reinstall(self):
         """Return ``True`` if the package is marked for reinstall."""
-        return self._pcache._depcache.MarkedReinstall(self._pkg)
+        return self._pcache._depcache.marked_reinstall(self._pkg)
 
     @property
     def is_installed(self):
         """Return ``True`` if the package is installed."""
-        return (self._pkg.CurrentVer is not None)
+        return (self._pkg.current_ver is not None)
 
     @property
     def is_upgradable(self):
         """Return ``True`` if the package is upgradable."""
         return (self.is_installed and
-                self._pcache._depcache.IsUpgradable(self._pkg))
+                self._pcache._depcache.is_upgradable(self._pkg))
 
     @property
     def is_auto_removable(self):
@@ -771,7 +771,7 @@ class Package(object):
         is no longer required.
         """
         return self.is_installed and \
-               self._pcache._depcache.IsGarbage(self._pkg)
+               self._pcache._depcache.is_garbage(self._pkg)
 
     # sizes
 
@@ -880,15 +880,15 @@ class Package(object):
             # sources.list
             # otherwise we fall back to the binary version number
             src_records = apt_pkg.SourceRecords()
-            src_rec = src_records.Lookup(src_pkg)
+            src_rec = src_records.lookup(src_pkg)
             if src_rec:
-                src_ver = src_records.Version
+                src_ver = src_records.version
                 #if apt_pkg.VersionCompare(binver, srcver) > 0:
                 #    srcver = binver
                 if not src_ver:
                     src_ver = bin_ver
                 #print "srcver: %s" % src_ver
-                section = src_records.Section
+                section = src_records.section
                 #print "srcsect: %s" % section
             else:
                 # fail into the error handler
@@ -954,8 +954,8 @@ class Package(object):
                         changelog_ver = match.group(1)
                         if changelog_ver and ":" in changelog_ver:
                             changelog_ver = changelog_ver.split(":", 1)[1]
-                        if (installed and apt_pkg.VersionCompare(changelog_ver,
-                                                              installed) <= 0):
+                        if (installed and apt_pkg.version_compare(
+                                          changelog_ver, installed) <= 0):
                             break
                     # EOF (shouldn't really happen)
                     changelog += line
@@ -992,14 +992,14 @@ class Package(object):
 
         .. versionadded:: 0.7.9
         """
-        return [Version(self, ver) for ver in self._pkg.VersionList]
+        return [Version(self, ver) for ver in self._pkg.version_list]
 
     # depcache actions
 
     def mark_keep(self):
         """Mark a package for keep."""
         self._pcache.cache_pre_change()
-        self._pcache._depcache.MarkKeep(self._pkg)
+        self._pcache._depcache.mark_keep(self._pkg)
         self._pcache.cache_post_change()
 
     @deprecated_args
@@ -1013,15 +1013,15 @@ class Package(object):
         as well.  The default is to keep the configuration.
         """
         self._pcache.cache_pre_change()
-        self._pcache._depcache.MarkDelete(self._pkg, purge)
+        self._pcache._depcache.mark_delete(self._pkg, purge)
         # try to fix broken stuffsta
-        if auto_fix and self._pcache._depcache.BrokenCount > 0:
+        if auto_fix and self._pcache._depcache.broken_count > 0:
             fix = apt_pkg.ProblemResolver(self._pcache._depcache)
-            fix.Clear(self._pkg)
-            fix.Protect(self._pkg)
-            fix.Remove(self._pkg)
-            fix.InstallProtect()
-            fix.Resolve()
+            fix.clear(self._pkg)
+            fix.protect(self._pkg)
+            fix.remove(self._pkg)
+            fix.install_protect()
+            fix.resolve()
         self._pcache.cache_post_change()
 
     @deprecated_args
@@ -1040,13 +1040,13 @@ class Package(object):
         when no other package depends on it.
         """
         self._pcache.cache_pre_change()
-        self._pcache._depcache.MarkInstall(self._pkg, auto_inst, from_user)
+        self._pcache._depcache.mark_install(self._pkg, auto_inst, from_user)
         # try to fix broken stuff
-        if auto_fix and self._pcache._depcache.BrokenCount > 0:
+        if auto_fix and self._pcache._depcache.broken_count > 0:
             fixer = apt_pkg.ProblemResolver(self._pcache._depcache)
-            fixer.Clear(self._pkg)
-            fixer.Protect(self._pkg)
-            fixer.Resolve(True)
+            fixer.clear(self._pkg)
+            fixer.protect(self._pkg)
+            fixer.resolve(True)
         self._pcache.cache_post_change()
 
     def mark_upgrade(self):
@@ -1056,7 +1056,7 @@ class Package(object):
         else:
             # FIXME: we may want to throw a exception here
             sys.stderr.write(("MarkUpgrade() called on a non-upgrable pkg: "
-                              "'%s'\n") % self._pkg.Name)
+                              "'%s'\n") % self._pkg.name)
 
     def commit(self, fprogress, iprogress):
         """Commit the changes.
@@ -1067,7 +1067,7 @@ class Package(object):
         The parameter *iprogress* refers to an InstallProgress() object, as
         found in apt.progress.
         """
-        self._pcache._depcache.Commit(fprogress, iprogress)
+        self._pcache._depcache.commit(fprogress, iprogress)
 
 
     if not apt_pkg._COMPAT_0_7:
@@ -1149,8 +1149,8 @@ def _test():
             if pkg.is_upgradable:
                 if random.randint(0, 1) == 1:
                     pkg.mark_install(i)
-        print "Broken: %s " % cache._depcache.BrokenCount
-        print "InstCount: %s " % cache._depcache.InstCount
+        print "Broken: %s " % cache._depcache.broken_count
+        print "InstCount: %s " % cache._depcache.inst_count
 
     print
     # get a new cache
@@ -1163,8 +1163,8 @@ def _test():
                     cache[name].mark_delete(i)
                 except SystemError:
                     print "Error trying to remove: %s " % name
-        print "Broken: %s " % cache._depcache.BrokenCount
-        print "DelCount: %s " % cache._depcache.DelCount
+        print "Broken: %s " % cache._depcache.broken_count
+        print "DelCount: %s " % cache._depcache.del_count
 
 # self-test
 if __name__ == "__main__":
diff --git a/apt/progress/__init__.py b/apt/progress/__init__.py
index 769942ce..d2a9d497 100644
--- a/apt/progress/__init__.py
+++ b/apt/progress/__init__.py
@@ -153,8 +153,8 @@ class TextFetchProgress(FetchProgress):
         FetchProgress.pulse(self)
         if self.currentCPS > 0:
             s = "[%2.f%%] %sB/s %s" % (self.percent,
-                                       apt_pkg.SizeToStr(int(self.currentCPS)),
-                                       apt_pkg.TimeToStr(int(self.eta)))
+                                       apt_pkg.size_to_str(int(self.currentCPS)),
+                                       apt_pkg.time_to_str(int(self.eta)))
         else:
             s = "%2.f%% [Working]" % (self.percent)
         print "\r%s" % (s),
@@ -184,7 +184,7 @@ class DumbInstallProgress(object):
 
     def run(self, pm):
         """Start installation."""
-        return pm.DoInstall()
+        return pm.do_install()
 
     def finishUpdate(self):
         """Called when update has finished."""
@@ -278,7 +278,7 @@ class InstallProgress(DumbInstallProgress):
         pid = self.fork()
         if pid == 0:
             # child
-            res = pm.DoInstall(self.writefd)
+            res = pm.do_install(self.writefd)
             os._exit(res)
         self.child_pid = pid
         res = self.waitChild()
diff --git a/apt/progress/gtk2.py b/apt/progress/gtk2.py
index 36d459bc..06ece2d5 100644
--- a/apt/progress/gtk2.py
+++ b/apt/progress/gtk2.py
@@ -247,7 +247,7 @@ class GFetchProgress(gobject.GObject, apt.progress.FetchProgress):
                       "%(speed)s/s") % \
                       {"current": currentItem,
                        "total": self.totalItems,
-                       "speed": apt_pkg.SizeToStr(self.currentCPS)})
+                       "speed": apt_pkg.size_to_str(self.currentCPS)})
         else:
             text = (_("Downloading file %(current)li of %(total)li") % \
                       {"current": currentItem,