* apt/*.py: Initial rename work for Bug#481061

A new module, apt.deprecation, is introduced containing functions and
classes which assist in the deprecation.

The apt_pkg extension gets a new attribute, _COMPAT_0_7 which can be set
by defining COMPAT_0_7 at compile time (-DCOMPAT_0_7).
      
The names are changed, and compatibility functions are enabled if
bool(apt_pkg._COMPAT_0_7) == True, i.e. if the package has been built with
backward compatibility fixes.

This commit changes the apt and aptsources packages, the apt_pkg and
apt_inst extensions will be the next renames.

7 files changed, 264 insertions, 105 deletions

diff --git a/apt/__init__.py b/apt/__init__.py
index ae2abbf2..734b3240 100644
--- a/apt/__init__.py
+++ b/apt/__init__.py
@@ -17,17 +17,21 @@
 #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
 #  USA
 # import the core of apt_pkg
+"""High-Level Interface for working with apt."""
 import apt_pkg
-import sys
-import os
 
 # import some fancy classes
 from apt.package import Package
 from apt.cache import Cache
-from apt.progress import (
-    OpProgress, FetchProgress, InstallProgress, CdromProgress)
 from apt.cdrom import Cdrom
-from apt_pkg import SizeToStr, TimeToStr, VersionCompare
+
+if apt_pkg._COMPAT_0_7:
+    from apt.progress import (OpProgress, FetchProgress, InstallProgress,
+                              CdromProgress)
+
+
+if apt_pkg._COMPAT_0_7:
+    from apt_pkg import SizeToStr, TimeToStr, VersionCompare
 
 # init the package system
 apt_pkg.init()
@@ -36,3 +40,4 @@ apt_pkg.init()
 #import warnings
 #warnings.warn("apt API not stable yet", FutureWarning)
 #del warnings
+__all__ = ['Cache', 'Cdrom', 'Package']
diff --git a/apt/cache.py b/apt/cache.py
index d13010af..928322d2 100644
--- a/apt/cache.py
+++ b/apt/cache.py
@@ -24,6 +24,7 @@ import weakref
 
 import apt_pkg
 from apt import Package
+from apt.deprecation import AttributeDeprecatedBy, function_deprecated_by
 import apt.progress
 
 
@@ -63,7 +64,7 @@ class Cache(object):
                                rootdir + "/var/lib/dpkg/status")
         self.open(progress)
 
-    def _runCallbacks(self, name):
+    def _run_callbacks(self, name):
         """ internal helper to run a callback """
         if name in self._callbacks:
             for callback in self._callbacks[name]:
@@ -75,7 +76,7 @@ class Cache(object):
         """
         if progress is None:
             progress = apt.progress.OpProgress()
-        self._runCallbacks("cache_pre_open")
+        self._run_callbacks("cache_pre_open")
         self._cache = apt_pkg.GetCache(progress)
         self._depcache = apt_pkg.GetDepCache(self._cache)
         self._records = apt_pkg.GetPkgRecords(self._cache)
@@ -98,7 +99,7 @@ class Cache(object):
             i += 1
 
         progress.done()
-        self._runCallbacks("cache_post_open")
+        self._run_callbacks("cache_post_open")
 
     def __getitem__(self, key):
         """ look like a dictionary (get key) """
@@ -128,12 +129,12 @@ class Cache(object):
     def keys(self):
         return list(self._set)
 
-    def getChanges(self):
+    def get_changes(self):
         """ Get the marked changes """
         changes = []
         for p in self:
-            if p.markedUpgrade or p.markedInstall or p.markedDelete or \
-               p.markedDowngrade or p.markedReinstall:
+            if p.marked_upgrade or p.marked_install or p.marked_delete or \
+               p.marked_downgrade or p.marked_reinstall:
                 changes.append(p)
         return changes
 
@@ -141,12 +142,12 @@ class Cache(object):
         """ Upgrade the all package, DistUpgrade will also install
             new dependencies
         """
-        self.cachePreChange()
+        self.cache_pre_change()
         self._depcache.Upgrade(distUpgrade)
-        self.cachePostChange()
+        self.cache_post_change()
 
     @property
-    def requiredDownload(self):
+    def required_download(self):
         """Get the size of the packages that are required to download."""
         pm = apt_pkg.GetPackageManager(self._depcache)
         fetcher = apt_pkg.GetAcquire()
@@ -154,12 +155,12 @@ class Cache(object):
         return fetcher.FetchNeeded
 
     @property
-    def additionalRequiredSpace(self):
+    def required_space(self):
         """Get the size of the additional required space on the fs."""
         return self._depcache.UsrSize
 
     @property
-    def reqReinstallPkgs(self):
+    def req_reinstall_pkgs(self):
         """Return the packages not downloadable packages in reqreinst state."""
         reqreinst = set()
         for pkg in self:
@@ -169,7 +170,7 @@ class Cache(object):
                 reqreinst.add(pkg.name)
         return reqreinst
 
-    def _runFetcher(self, fetcher):
+    def _run_fetcher(self, fetcher):
         # do the actual fetching
         res = fetcher.Run()
 
@@ -194,7 +195,7 @@ class Cache(object):
             raise FetchFailedException(errMsg)
         return res
 
-    def _fetchArchives(self, fetcher, pm):
+    def _fetch_archives(self, fetcher, pm):
         """ fetch the needed archives """
 
         # get lock
@@ -209,16 +210,16 @@ class Cache(object):
                 return False
             # now run the fetcher, throw exception if something fails to be
             # fetched
-            return self._runFetcher(fetcher)
+            return self._run_fetcher(fetcher)
         finally:
             os.close(lock)
 
-    def isVirtualPackage(self, pkgname):
+    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)
 
-    def getProvidingPackages(self, virtual):
+    def get_providing_packages(self, virtual):
         """
         Return a list of packages which provide the virtual package of the
         specified name
@@ -254,10 +255,16 @@ class Cache(object):
         finally:
             os.close(lock)
 
-    def installArchives(self, pm, installProgress):
-        installProgress.startUpdate()
+    def install_archives(self, pm, installProgress):
+        try:
+            installProgress.start_update()
+        except AttributeError:
+            installProgress.startUpdate()
         res = installProgress.run(pm)
-        installProgress.finishUpdate()
+        try:
+            installProgress.finish_update()
+        except AttributeError:
+            installProgress.finishUpdate()
         return res
 
     def commit(self, fetchProgress=None, installProgress=None):
@@ -278,10 +285,10 @@ class Cache(object):
         fetcher = apt_pkg.GetAcquire(fetchProgress)
         while True:
             # fetch archives first
-            res = self._fetchArchives(fetcher, pm)
+            res = self._fetch_archives(fetcher, pm)
 
             # then install
-            res = self.installArchives(pm, installProgress)
+            res = self.install_archives(pm, installProgress)
             if res == pm.ResultCompleted:
                 break
             if res == pm.ResultFailed:
@@ -296,14 +303,14 @@ class Cache(object):
 
     # cache changes
 
-    def cachePostChange(self):
+    def cache_post_change(self):
         " called internally if the cache has changed, emit a signal then "
-        self._runCallbacks("cache_post_change")
+        self._run_callbacks("cache_post_change")
 
-    def cachePreChange(self):
+    def cache_pre_change(self):
         """ called internally if the cache is about to change, emit
             a signal then """
-        self._runCallbacks("cache_pre_change")
+        self._run_callbacks("cache_pre_change")
 
     def connect(self, name, callback):
         """ connect to a signal, currently only used for
@@ -312,6 +319,20 @@ class Cache(object):
             self._callbacks[name] = []
         self._callbacks[name].append(callback)
 
+    if apt_pkg._COMPAT_0_7:
+        _runCallbacks = function_deprecated_by(_run_callbacks)
+        getChanges = function_deprecated_by(get_changes)
+        requiredDownload = AttributeDeprecatedBy('required_download')
+        additionalRequiredSpace = AttributeDeprecatedBy('required_space')
+        reqReinstallPkgs = AttributeDeprecatedBy('req_reinstall_pkgs')
+        _runFetcher = function_deprecated_by(_run_fetcher)
+        _fetchArchives = function_deprecated_by(_fetch_archives)
+        isVirtualPackage = function_deprecated_by(is_virtual_package)
+        getProvidingPackages = function_deprecated_by(get_providing_packages)
+        installArchives = function_deprecated_by(install_archives)
+        cachePostChange = function_deprecated_by(cache_post_change)
+        cachePreChange = function_deprecated_by(cache_pre_change)
+
 
 # ----------------------------- experimental interface
 
@@ -330,7 +351,7 @@ class MarkedChangesFilter(Filter):
     """ Filter that returns all marked changes """
 
     def apply(self, pkg):
-        if pkg.markedInstall or pkg.markedDelete or pkg.markedUpgrade:
+        if pkg.marked_install or pkg.marked_delete or pkg.marked_upgrade:
             return True
         else:
             return False
@@ -347,8 +368,8 @@ class FilteredCache(object):
             self.cache = Cache(progress)
         else:
             self.cache = cache
-        self.cache.connect("cache_post_change", self.filterCachePostChange)
-        self.cache.connect("cache_post_open", self.filterCachePostChange)
+        self.cache.connect("cache_post_change", self.filter_cache_post_change)
+        self.cache.connect("cache_post_open", self.filter_cache_post_change)
         self._filtered = {}
         self._filters = []
 
@@ -371,7 +392,7 @@ class FilteredCache(object):
     def __contains__(self, key):
         return (key in self._filtered)
 
-    def _reapplyFilter(self):
+    def _reapply_filter(self):
         " internal helper to refilter "
         self._filtered = {}
         for pkg in self.cache:
@@ -380,18 +401,19 @@ class FilteredCache(object):
                     self._filtered[pkg.name] = 1
                     break
 
-    def setFilter(self, filter):
+    def set_filter(self, filter):
         """Set the current active filter."""
         self._filters = []
         self._filters.append(filter)
         #self._reapplyFilter()
         # force a cache-change event that will result in a refiltering
-        self.cache.cachePostChange()
+        self.cache.cache_post_change()
 
-    def filterCachePostChange(self):
+    def filter_cache_post_change(self):
         """Called internally if the cache changes, emit a signal then."""
         #print "filterCachePostChange()"
-        self._reapplyFilter()
+        self._reapply_filter()
+
 
 #    def connect(self, name, callback):
 #        self.cache.connect(name, callback)
@@ -401,6 +423,12 @@ class FilteredCache(object):
         #print "getattr: %s " % key
         return getattr(self.cache, key)
 
+    if apt_pkg._COMPAT_0_7:
+        _reapplyFilter = function_deprecated_by(_reapply_filter)
+        setFilter = function_deprecated_by(set_filter)
+        filterCachePostChange = function_deprecated_by(\
+                                                    filter_cache_post_change)
+
 
 def cache_pre_changed():
     print "cache pre changed"
@@ -410,8 +438,8 @@ def cache_post_changed():
     print "cache post changed"
 
 
-# internal test code
-if __name__ == "__main__":
+def _test():
+    """Internal test code."""
     print "Cache self test"
     apt_pkg.init()
     c = Cache(apt.progress.OpTextProgress())
@@ -426,7 +454,7 @@ if __name__ == "__main__":
         x= c[pkg].name
 
     c.upgrade()
-    changes = c.getChanges()
+    changes = c.get_changes()
     print len(changes)
     for p in changes:
         #print p.name
@@ -440,7 +468,7 @@ if __name__ == "__main__":
     apt_pkg.Config.Set("Dir::Cache::Archives", "/tmp/pytest")
     pm = apt_pkg.GetPackageManager(c._depcache)
     fetcher = apt_pkg.GetAcquire(apt.progress.TextFetchProgress())
-    c._fetchArchives(fetcher, pm)
+    c._fetch_archives(fetcher, pm)
     #sys.exit(1)
 
     print "Testing filtered cache (argument is old cache)"
@@ -448,7 +476,7 @@ if __name__ == "__main__":
     f.cache.connect("cache_pre_change", cache_pre_changed)
     f.cache.connect("cache_post_change", cache_post_changed)
     f.cache.upgrade()
-    f.setFilter(MarkedChangesFilter())
+    f.set_filter(MarkedChangesFilter())
     print len(f)
     for pkg in f.keys():
         #print c[pkg].name
@@ -461,10 +489,12 @@ if __name__ == "__main__":
     f.cache.connect("cache_pre_change", cache_pre_changed)
     f.cache.connect("cache_post_change", cache_post_changed)
     f.cache.upgrade()
-    f.setFilter(MarkedChangesFilter())
+    f.set_filter(MarkedChangesFilter())
     print len(f)
     for pkg in f.keys():
         #print c[pkg].name
         x = f[pkg].name
 
     print len(f)
+if __name__ == '__main__':
+    _test()
diff --git a/apt/cdrom.py b/apt/cdrom.py
index b52762ad..907ac622 100644
--- a/apt/cdrom.py
+++ b/apt/cdrom.py
@@ -24,6 +24,7 @@ import glob
 
 import apt_pkg
 from apt.progress import CdromProgress
+from apt.deprecation import AttributeDeprecatedBy
 
 
 class Cdrom(object):
@@ -69,7 +70,7 @@ class Cdrom(object):
             return ident
 
     @property
-    def inSourcesList(self):
+    def in_sources_list(self):
         """Check if the cdrom is already in the current sources.list."""
         cd_id = self.ident()
         if cd_id is None:
@@ -84,3 +85,6 @@ class Cdrom(object):
                 if not line.lstrip().startswith("#") and cd_id in line:
                     return True
         return False
+
+    if apt_pkg._COMPAT_0_7:
+        inSourcesList = AttributeDeprecatedBy('in_sources_list')
diff --git a/apt/debfile.py b/apt/debfile.py
index 8d4f534c..c60fc92d 100644
--- a/apt/debfile.py
+++ b/apt/debfile.py
@@ -97,11 +97,11 @@ class DebPackage(object):
 
             # check for virtual pkgs
             if not depname in self._cache:
-                if self._cache.isVirtualPackage(depname):
+                if self._cache.is_virtual_package(depname):
                     self._dbg(3, "_isOrGroupSatisfied(): %s is virtual dep" %
                                  depname)
-                    for pkg in self._cache.getProvidingPackages(depname):
-                        if pkg.isInstalled:
+                    for pkg in self._cache.get_providing_packages(depname):
+                        if pkg.is_installed:
                             return True
                 continue
 
@@ -117,9 +117,9 @@ class DebPackage(object):
 
             # if we don't have it in the cache, it may be virtual
             if not depname in self._cache:
-                if not self._cache.isVirtualPackage(depname):
+                if not self._cache.is_virtual_package(depname):
                     continue
-                providers = self._cache.getProvidingPackages(depname)
+                providers = self._cache.get_providing_packages(depname)
                 # if a package just has a single virtual provider, we
                 # just pick that (just like apt)
                 if len(providers) != 1:
@@ -158,9 +158,9 @@ class DebPackage(object):
                      (pkgname, ver, oper))
 
         pkg = self._cache[pkgname]
-        if pkg.isInstalled:
+        if pkg.is_installed:
             pkgver = pkg.installed.version
-        elif pkg.markedInstall:
+        elif pkg.marked_install:
             pkgver = pkg.candidate.version
         else:
             return False
@@ -191,8 +191,8 @@ class DebPackage(object):
             if not depname in self._cache:
                 # FIXME: we have to check for virtual replaces here as
                 #        well (to pass tests/gdebi-test8.deb)
-                if self._cache.isVirtualPackage(depname):
-                    for pkg in self._cache.getProvidingPackages(depname):
+                if self._cache.is_virtual_package(depname):
+                    for pkg in self._cache.get_providing_packages(depname):
                         self._dbg(3, "conflicts virtual check: %s" % pkg.name)
                         # P/C/R on virtal pkg, e.g. ftpd
                         if self.pkgname == pkg.name:
@@ -253,9 +253,9 @@ class DebPackage(object):
         """
         self._dbg(3, "replacesPkg() %s %s %s" % (pkgname, oper, ver))
         pkg = self._cache[pkgname]
-        if pkg.isInstalled:
+        if pkg.is_installed:
             pkgver = pkg.installed.version
-        elif pkg.markedInstall:
+        elif pkg.marked_install:
             pkgver = pkg.candidate.version
         else:
             pkgver = None
@@ -371,7 +371,7 @@ class DebPackage(object):
         # now try it out in the cache
         for pkg in self._need_pkgs:
             try:
-                self._cache[pkg].markInstall(fromUser=False)
+                self._cache[pkg].mark_install(fromUser=False)
             except SystemError, e:
                 self._failure_string = _("Cannot install '%s'" % pkg)
                 self._cache.clear()
@@ -396,7 +396,7 @@ class DebPackage(object):
         remove = []
         unauthenticated = []
         for pkg in self._cache:
-            if pkg.markedInstall or pkg.markedUpgrade:
+            if pkg.marked_install or pkg.marked_upgrade:
                 install.append(pkg.name)
                 # check authentication, one authenticated origin is enough
                 # libapt will skip non-authenticated origins then
@@ -405,7 +405,7 @@ class DebPackage(object):
                     authenticated |= origin.trusted
                 if not authenticated:
                     unauthenticated.append(pkg.name)
-            if pkg.markedDelete:
+            if pkg.marked_delete:
                 remove.append(pkg.name)
         return (install, remove, unauthenticated)
 
@@ -492,7 +492,7 @@ class DscSrcPackage(DebPackage):
             for pkgname in self._installed_conflicts:
                 if self._cache[pkgname]._pkg.Essential:
                     raise Exception(_("An essential package would be removed"))
-                self._cache[pkgname].markDelete()
+                self._cache[pkgname].mark_delete()
         # FIXME: a additional run of the checkConflicts()
         #        after _satisfyDepends() should probably be done
         return self._satisfy_depends(self.depends)
@@ -507,7 +507,7 @@ def _test():
 
     vp = "www-browser"
     #print "%s virtual: %s" % (vp, cache.isVirtualPackage(vp))
-    providers = cache.getProvidingPackages(vp)
+    providers = cache.get_providing_packages(vp)
     print "Providers for %s :" % vp
     for pkg in providers:
         print " %s" % pkg.name
diff --git a/apt/deprecation.py b/apt/deprecation.py
new file mode 100644
index 00000000..a14d49e6
--- /dev/null
+++ b/apt/deprecation.py
@@ -0,0 +1,76 @@
+# deprecation.py - Module providing classes and functions for deprecation.
+#
+#  Copyright (c) 2009 Julian Andres Klode <jak@debian.org>
+#  Copyright (c) 2009 Ben Finney <ben+debian@benfinney.id.au>
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License as
+#  published by the Free Software Foundation; either version 2 of the
+#  License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+#  USA
+"""Classes and functions for deprecating features.
+
+This is used for internal purposes only and not part of the official API. Do
+not use it for anything outside the apt package.
+"""
+import re
+import operator
+import warnings
+
+__all__ = []
+
+
+class AttributeDeprecatedBy(object):
+    """Property acting as a proxy for a new attribute.
+
+    When accessed, the property issues a DeprecationWarning and (on get) calls
+    attrgetter() for the attribute 'attribute' on the current object or (on
+    set) uses setattr to set the value of the wrapped attribute.
+    """
+
+    def __init__(self, attribute):
+        """Initialize the property."""
+        self.attribute = attribute
+        self.__doc__ = 'Deprecated, please use \'%s\' instead' % attribute
+        self.getter = operator.attrgetter(attribute)
+
+    def __get__(self, obj, type=None):
+        """Issue a  DeprecationWarning and return the requested value."""
+        if obj is None:
+            return getattr(type, self.attribute, self)
+        warnings.warn(self.__doc__, DeprecationWarning, stacklevel=2)
+        return self.getter(obj or type)
+
+    def __set__(self, obj, value):
+        """Issue a  DeprecationWarning and set the requested value."""
+        warnings.warn(self.__doc__, DeprecationWarning, stacklevel=2)
+        setattr(obj, self.attribute, value)
+
+
+def function_deprecated_by(func, convert_names=True):
+    """Return a function that warns it is deprecated by another function.
+
+    Returns a new function that warns it is deprecated by function 'func',
+    then acts as a pass-through wrapper for 'func'.
+
+    This function also converts all keyword argument names from mixedCase to
+    lowercase_with_underscores, but only if 'convert_names' is True (default).
+    """
+    warning = 'Deprecated, please use \'%s\' instead' % func.func_name
+
+    def deprecated_function(*args, **kwds):
+        warnings.warn(warning, DeprecationWarning, stacklevel=2)
+        if convert_names:
+            for key in kwds.keys():
+                kwds[re.sub('([A-Z])', '_\\1', key).lower()] = kwds.pop(key)
+        return func(*args, **kwds)
+    return deprecated_function
diff --git a/apt/package.py b/apt/package.py
index db5696ae..70997383 100644
--- a/apt/package.py
+++ b/apt/package.py
@@ -31,6 +31,7 @@ import warnings
 
 import apt_pkg
 import apt.progress
+from apt.deprecation import function_deprecated_by, AttributeDeprecatedBy
 
 __all__ = ('BaseDependency', 'Dependency', 'Origin', 'Package', 'Record',
            'Version')
@@ -56,21 +57,24 @@ class BaseDependency(object):
     """A single dependency.
 
     Attributes defined here:
-        name      - The name of the dependency
-        relation  - The relation (>>,>=,==,<<,<=,)
-        version   - The version depended on
-        preDepend - Boolean value whether this is a pre-dependency.
+        name       - The name of the dependency
+        relation   - The relation (>>,>=,==,<<,<=,)
+        version    - The version depended on
+        pre_depend - Boolean value whether this is a pre-dependency.
     """
 
     def __init__(self, name, rel, ver, pre):
         self.name = name
         self.relation = rel
         self.version = ver
-        self.preDepend = pre
+        self.pre_depend = pre
 
     def __repr__(self):
         return ('<BaseDependency: name:%r relation:%r version:%r preDepend:%r>'
-                % (self.name, self.relation, self.version, self.preDepend))
+                % (self.name, self.relation, self.version, self.pre_depend))
+
+    if apt_pkg._COMPAT_0_7:
+        preDepend = AttributeDeprecatedBy('pre_depend')
 
 
 class Dependency(object):
@@ -103,7 +107,7 @@ class DeprecatedProperty(property):
             warnings.warn("Accessed deprecated property %s.%s, please see the "
                           "Version class for alternatives." %
                            ((obj.__class__.__name__ or type.__name__),
-                           self.fget.func_name), DeprecationWarning, 2)
+                           self.fget.__name__), DeprecationWarning, 2)
         return property.__get__(self, obj, type)
 
 
@@ -528,9 +532,9 @@ class Package(object):
 
     def __set_candidate(self, version):
         """Set the candidate version of the package."""
-        self._pcache.cachePreChange()
+        self._pcache.cache_pre_change()
         self._pcache._depcache.SetCandidateVer(self._pkg, version._cand)
-        self._pcache.cachePostChange()
+        self._pcache.cache_post_change()
 
     candidate = property(candidate, __set_candidate)
 
@@ -703,55 +707,56 @@ class Package(object):
     # depcache states
 
     @property
-    def markedInstall(self):
+    def marked_install(self):
         """Return ``True`` if the package is marked for install."""
         return self._pcache._depcache.MarkedInstall(self._pkg)
 
     @property
-    def markedUpgrade(self):
+    def marked_upgrade(self):
         """Return ``True`` if the package is marked for upgrade."""
         return self._pcache._depcache.MarkedUpgrade(self._pkg)
 
     @property
-    def markedDelete(self):
+    def marked_delete(self):
         """Return ``True`` if the package is marked for delete."""
         return self._pcache._depcache.MarkedDelete(self._pkg)
 
     @property
-    def markedKeep(self):
+    def marked_keep(self):
         """Return ``True`` if the package is marked for keep."""
         return self._pcache._depcache.MarkedKeep(self._pkg)
 
     @property
-    def markedDowngrade(self):
+    def marked_downgrade(self):
         """ Package is marked for downgrade """
         return self._pcache._depcache.MarkedDowngrade(self._pkg)
 
     @property
-    def markedReinstall(self):
+    def marked_reinstall(self):
         """Return ``True`` if the package is marked for reinstall."""
         return self._pcache._depcache.MarkedReinstall(self._pkg)
 
     @property
-    def isInstalled(self):
+    def is_installed(self):
         """Return ``True`` if the package is installed."""
         return (self._pkg.CurrentVer is not None)
 
     @property
-    def isUpgradable(self):
+    def is_upgradable(self):
         """Return ``True`` if the package is upgradable."""
-        return (self.isInstalled and
+        return (self.is_installed and
                 self._pcache._depcache.IsUpgradable(self._pkg))
 
     @property
-    def isAutoRemovable(self):
+    def is_auto_removable(self):
         """Return ``True`` if the package is no longer required.
 
         If the package has been installed automatically as a dependency of
         another package, and if no packages depend on it anymore, the package
         is no longer required.
         """
-        return self.isInstalled and self._pcache._depcache.IsGarbage(self._pkg)
+        return self.is_installed and \
+               self._pcache._depcache.IsGarbage(self._pkg)
 
     # sizes
 
@@ -789,7 +794,7 @@ class Package(object):
         return getattr(self.installed, 'installed_size', 0)
 
     @property
-    def installedFiles(self):
+    def installed_files(self):
         """Return a list of files installed by the package.
 
         Return a list of unicode names of the files which have
@@ -805,7 +810,7 @@ class Package(object):
         except EnvironmentError:
             return []
 
-    def getChangelog(self, uri=None, cancel_lock=None):
+    def get_changelog(self, uri=None, cancel_lock=None):
         """
         Download the changelog of the package and return it as unicode
         string.
@@ -928,7 +933,7 @@ class Package(object):
                     if match:
                         # strip epoch from installed version
                         # and from changelog too
-                        installed = self.installedVersion
+                        installed = getattr(self.installed, 'version', None)
                         if installed and ":" in installed:
                             installed = installed.split(":", 1)[1]
                         changelog_ver = match.group(1)
@@ -976,13 +981,13 @@ class Package(object):
 
     # depcache actions
 
-    def markKeep(self):
+    def mark_keep(self):
         """Mark a package for keep."""
-        self._pcache.cachePreChange()
+        self._pcache.cache_pre_change()
         self._pcache._depcache.MarkKeep(self._pkg)
-        self._pcache.cachePostChange()
+        self._pcache.cache_post_change()
 
-    def markDelete(self, autoFix=True, purge=False):
+    def mark_delete(self, autoFix=True, purge=False):
         """Mark a package for install.
 
         If *autoFix* is ``True``, the resolver will be run, trying to fix
@@ -991,7 +996,7 @@ class Package(object):
         If *purge* is ``True``, remove the configuration files of the package
         as well.  The default is to keep the configuration.
         """
-        self._pcache.cachePreChange()
+        self._pcache.cache_pre_change()
         self._pcache._depcache.MarkDelete(self._pkg, purge)
         # try to fix broken stuffsta
         if autoFix and self._pcache._depcache.BrokenCount > 0:
@@ -1001,9 +1006,9 @@ class Package(object):
             Fix.Remove(self._pkg)
             Fix.InstallProtect()
             Fix.Resolve()
-        self._pcache.cachePostChange()
+        self._pcache.cache_post_change()
 
-    def markInstall(self, autoFix=True, autoInst=True, fromUser=True):
+    def mark_install(self, autoFix=True, autoInst=True, fromUser=True):
         """Mark a package for install.
 
         If *autoFix* is ``True``, the resolver will be run, trying to fix
@@ -1017,7 +1022,7 @@ class Package(object):
         want to be able to automatically remove the package at a later stage
         when no other package depends on it.
         """
-        self._pcache.cachePreChange()
+        self._pcache.cache_pre_change()
         self._pcache._depcache.MarkInstall(self._pkg, autoInst, fromUser)
         # try to fix broken stuff
         if autoFix and self._pcache._depcache.BrokenCount > 0:
@@ -1025,12 +1030,12 @@ class Package(object):
             fixer.Clear(self._pkg)
             fixer.Protect(self._pkg)
             fixer.Resolve(True)
-        self._pcache.cachePostChange()
+        self._pcache.cache_post_change()
 
-    def markUpgrade(self):
+    def mark_upgrade(self):
         """Mark a package for upgrade."""
-        if self.isUpgradable:
-            self.markInstall()
+        if self.is_upgradable:
+            self.mark_install()
         else:
             # FIXME: we may want to throw a exception here
             sys.stderr.write(("MarkUpgrade() called on a non-upgrable pkg: "
@@ -1048,11 +1053,50 @@ class Package(object):
         self._pcache._depcache.Commit(fprogress, iprogress)
 
 
+    if not apt_pkg._COMPAT_0_7:
+        del installedVersion
+        del candidateVersion
+        del candidateDependencies
+        del installedDependencies
+        del architecture
+        del candidateDownloadable
+        del installedDownloadable
+        del sourcePackageName
+        del homepage
+        del priority
+        del installedPriority
+        del summary
+        del description
+        del rawDescription
+        del candidateRecord
+        del installedRecord
+        del packageSize
+        del installedPackageSize
+        del candidateInstalledSize
+        del installedSize
+        del candidateOrigin
+    else:
+        markedInstalled = AttributeDeprecatedBy('marked_installed')
+        markedUpgrade = AttributeDeprecatedBy('marked_upgrade')
+        markedDelete = AttributeDeprecatedBy('marked_delete')
+        markedKeep = AttributeDeprecatedBy('marked_keep')
+        markedDowngrade = AttributeDeprecatedBy('marked_downgrade')
+        markedReinstall = AttributeDeprecatedBy('marked_reinstall')
+        isInstalled = AttributeDeprecatedBy('is_installed')
+        isUpgradable = AttributeDeprecatedBy('is_upgradable')
+        isAutoRemovable = AttributeDeprecatedBy('is_auto_removable')
+        installedFiles = AttributeDeprecatedBy('installed_files')
+        getChangelog = function_deprecated_by(get_changelog)
+        markDelete = function_deprecated_by(mark_delete)
+        markInstall = function_deprecated_by(mark_install)
+        markKeep = function_deprecated_by(mark_keep)
+        markUpgrade = function_deprecated_by(mark_upgrade)
+
+
 def _test():
     """Self-test."""
     print "Self-test for the Package modul"
     import random
-    import apt
     apt_pkg.init()
     progress = apt.progress.OpTextProgress()
     cache = apt.Cache(progress)
@@ -1075,19 +1119,19 @@ def _test():
     print "Dependencies: %s" % pkg.installed.dependencies
     for dep in pkg.candidate.dependencies:
         print ",".join("%s (%s) (%s) (%s)" % (o.name, o.version, o.relation,
-                        o.preDepend) for o in dep.or_dependencies)
+                        o.pre_depend) for o in dep.or_dependencies)
     print "arch: %s" % pkg.candidate.architecture
     print "homepage: %s" % pkg.candidate.homepage
     print "rec: ", pkg.candidate.record
 
 
-    print cache["2vcard"].getChangelog()
+    print cache["2vcard"].get_changelog()
     for i in True, False:
         print "Running install on random upgradable pkgs with AutoFix: %s " % i
         for pkg in cache:
-            if pkg.isUpgradable:
+            if pkg.is_upgradable:
                 if random.randint(0, 1) == 1:
-                    pkg.markInstall(i)
+                    pkg.mark_install(i)
         print "Broken: %s " % cache._depcache.BrokenCount
         print "InstCount: %s " % cache._depcache.InstCount
 
@@ -1099,7 +1143,7 @@ def _test():
         for name in cache.keys():
             if random.randint(0, 1) == 1:
                 try:
-                    cache[name].markDelete(i)
+                    cache[name].mark_delete(i)
                 except SystemError:
                     print "Error trying to remove: %s " % name
         print "Broken: %s " % cache._depcache.BrokenCount
diff --git a/apt/progress/gtk2.py b/apt/progress/gtk2.py
index f872e34f..36d459bc 100644
--- a/apt/progress/gtk2.py
+++ b/apt/progress/gtk2.py
@@ -422,10 +422,10 @@ def _test():
     win.show()
     cache = apt.cache.Cache(apt_progress.open)
     pkg = cache["xterm"]
-    if pkg.isInstalled:
-        pkg.markDelete()
+    if pkg.is_installed:
+        pkg.mark_delete()
     else:
-        pkg.markInstall()
+        pkg.mark_install()
     apt_progress.show_terminal(True)
     try:
         cache.commit(apt_progress.fetch, apt_progress.install)