merge from debian, omit disable of the 0.7 API

6 files changed, 92 insertions, 21 deletions

diff --git a/apt/cache.py b/apt/cache.py
index bfa41edc..be137b76 100644
--- a/apt/cache.py
+++ b/apt/cache.py
@@ -66,7 +66,11 @@ class Cache(object):
         self._weakref = weakref.WeakValueDictionary()
         self._set = set()
         self._fullnameset = set()
+        self._changes_count = -1
         self._sorted_set = None
+        
+        self.connect("cache_post_open", self._inc_changes_count)
+        self.connect("cache_post_change", self._inc_changes_count)
         if memonly:
             # force apt to build its caches in memory
             apt_pkg.config.set("Dir::Cache::pkgcache", "")
@@ -87,6 +91,11 @@ class Cache(object):
             # recognized (LP: #320665)
             apt_pkg.init_system()
         self.open(progress)
+        
+
+    def _inc_changes_count(self):
+        """Increase the number of changes"""
+        self._changes_count += 1
 
     def _check_and_create_required_dirs(self, rootdir):
         """
@@ -107,7 +116,7 @@ class Cache(object):
                 os.makedirs(rootdir + d)
         for f in files:
             if not os.path.exists(rootdir + f):
-                open(rootdir + f, "w")
+                open(rootdir + f, "w").close()
 
     def _run_callbacks(self, name):
         """ internal helper to run a callback """
@@ -288,6 +297,30 @@ class Cache(object):
         finally:
             os.close(lock)
 
+    def fetch_archives(self, progress=None, fetcher=None):
+        """Fetch the archives for all packages marked for install/upgrade.
+
+        You can specify either an :class:`apt.progress.base.AcquireProgress()`
+        object for the parameter *progress*, or specify an already
+        existing :class:`apt_pkg.Acquire` object for the parameter *fetcher*.
+
+        The return value of the function is undefined. If an error occured,
+        an exception of type :class:`FetchFailedException` or
+        :class:`FetchCancelledException` is raised.
+
+        .. versionadded:: 0.8.0
+        """
+        if progress is not None and fetcher is not None:
+            raise ValueError("Takes a progress or a an Acquire object")
+        if progress is None:
+            progress = apt.progress.text.AcquireProgress()
+        if fetcher is None:
+            fetcher = apt_pkg.Acquire(progress)
+
+        
+        return self._fetch_archives(fetcher,
+                                    apt_pkg.PackageManager(self._depcache))
+
     def is_virtual_package(self, pkgname):
         """Return whether the package is a virtual package."""
         try:
@@ -339,6 +372,10 @@ class Cache(object):
                raise_on_error=True, sources_list=None):
         """Run the equivalent of apt-get update.
 
+        You probably want to call open() afterwards, in order to utilise the
+        new cache. Otherwise, the old cache will be used which can lead to
+        strange bugs.
+
         The first parameter *fetch_progress* may be set to an instance of
         apt.progress.FetchProgress, the default is apt.progress.FetchProgress()
         .
@@ -548,6 +585,7 @@ class ProblemResolver(object):
 
     def __init__(self, cache):
         self._resolver = apt_pkg.ProblemResolver(cache._depcache)
+        self._cache = cache
 
     def clear(self, package):
         """Reset the package to the default state."""
@@ -567,11 +605,15 @@ class ProblemResolver(object):
 
     def resolve(self):
         """Resolve dependencies, try to remove packages where needed."""
+        self._cache.cache_pre_change()
         self._resolver.resolve()
+        self._cache.cache_post_change()
 
     def resolve_by_keep(self):
         """Resolve dependencies, do not try to remove packages."""
+        self._cache.cache_pre_change()
         self._resolver.resolve_by_keep()
+        self._cache.cache_post_change()
 
 
 # ----------------------------- experimental interface
diff --git a/apt/cdrom.py b/apt/cdrom.py
index 01caa12f..9688de9e 100644
--- a/apt/cdrom.py
+++ b/apt/cdrom.py
@@ -79,9 +79,10 @@ class Cdrom(apt_pkg.Cdrom):
         src.append(apt_pkg.config.find_file("Dir::Etc::sourcelist"))
         # Check each file
         for fname in src:
-            for line in open(fname):
-                if not line.lstrip().startswith("#") and cd_id in line:
-                    return True
+            with open(fname) as fobj:
+                for line in fobj:
+                    if not line.lstrip().startswith("#") and cd_id in line:
+                        return True
         return False
 
     if apt_pkg._COMPAT_0_7:
diff --git a/apt/debfile.py b/apt/debfile.py
index fb4312a1..d0f41def 100644
--- a/apt/debfile.py
+++ b/apt/debfile.py
@@ -64,7 +64,7 @@ class DebPackage(object):
         self._installed_conflicts = set()
         self._failure_string = ""
         self.filename = filename
-        self._debfile = apt_inst.DebFile(open(self.filename))
+        self._debfile = apt_inst.DebFile(self.filename)
         control = self._debfile.control.extractdata("control")
         self._sections = apt_pkg.TagSection(control)
         self.pkgname = self._sections["Package"]
diff --git a/apt/package.py b/apt/package.py
index d7d5d167..14e80594 100644
--- a/apt/package.py
+++ b/apt/package.py
@@ -50,9 +50,9 @@ __all__ = ('BaseDependency', 'Dependency', 'Origin', 'Package', 'Record',
 
 def _file_is_same(path, size, md5):
     """Return ``True`` if the file is the same."""
-    if (os.path.exists(path) and os.path.getsize(path) == size and
-        apt_pkg.md5sum(open(path)) == md5):
-        return True
+    if os.path.exists(path) and os.path.getsize(path) == size:
+        with open(path) as fobj:
+            return apt_pkg.md5sum(fobj) == md5
 
 
 class FetchError(Exception):
@@ -162,10 +162,23 @@ class Origin(object):
 
 
 class Record(Mapping):
-    """Represent a pkgRecord.
+    """Record in a Packages file
+
+    Represent a record as stored in a Packages file. You can use this like
+    a dictionary mapping the field names of the record to their values::
+
+        >>> record = Record("Package: python-apt\\nVersion: 0.8.0\\n\\n")
+        >>> record["Package"]
+        'python-apt'
+        >>> record["Version"]
+        '0.8.0'
+
+    For example, to get the tasks of a package from a cache, you could do::
+
+        package.candidate.record["Tasks"].split()
+
+    Of course, you can also use the :attr:`Version.tasks` property.
 
-    It can be accessed like a dictionary and can also give the original package
-    record if accessed as a string.
     """
 
     def __init__(self, record_str):
@@ -209,6 +222,9 @@ class Record(Mapping):
 class Version(object):
     """Representation of a package version.
 
+    The Version class contains all information related to a
+    specific package version.
+
     .. versionadded:: 0.7.9
     """
 
@@ -393,7 +409,11 @@ class Version(object):
 
     @property
     def record(self):
-        """Return a Record() object for this version."""
+        """Return a Record() object for this version.
+
+        Return a Record() object for this version which provides access
+        to the raw attributes of the candidate version
+        """
         return Record(self._records.record)
 
     def get_dependencies(self, *types):
@@ -474,6 +494,16 @@ class Version(object):
         """
         return self._records.sha256_hash
 
+    @property
+    def tasks(self):
+        """Get the tasks of the package.
+
+        A set of the names of the tasks this package belongs to.
+
+        .. versionadded:: 0.8.0
+        """
+        return set(self.record["Task"].split())
+
     def _uris(self):
         """Return an iterator over all available urls.
 
@@ -994,11 +1024,8 @@ class Package(object):
         """
         path = "/var/lib/dpkg/info/%s.list" % self.name
         try:
-            file_list = open(path, "rb")
-            try:
+            with open(path, "rb") as file_list:
                 return file_list.read().decode("utf-8").split(u"\n")
-            finally:
-                file_list.close()
         except EnvironmentError:
             return []
 
@@ -1104,6 +1131,7 @@ class Package(object):
                 # Check if the download was canceled
                 if cancel_lock and cancel_lock.isSet():
                     return u""
+                # FIXME: python3.2: Should be closed manually
                 changelog_file = urllib2.urlopen(uri)
                 # do only get the lines that are new
                 changelog = u""
diff --git a/apt/progress/old.py b/apt/progress/old.py
index 4bd79f2e..364cd2ce 100644
--- a/apt/progress/old.py
+++ b/apt/progress/old.py
@@ -149,10 +149,11 @@ class TextFetchProgress(FetchProgress):
         Return True to continue or False to cancel.
         """
         FetchProgress.pulse(self)
+
         if self.currentCPS > 0:
             s = "[%2.f%%] %sB/s %s" % (self.percent,
-                                    apt_pkg.size_to_str(int(self.currentCPS)),
-                                    apt_pkg.time_to_str(int(self.eta)))
+                                    apt_pkg.size_to_str(self.currentCPS),
+                                    apt_pkg.time_to_str(long(self.eta)))
         else:
             s = "%2.f%% [Working]" % (self.percent)
         print "\r%s" % (s),
diff --git a/apt/progress/text.py b/apt/progress/text.py
index d777837c..c5eec092 100644
--- a/apt/progress/text.py
+++ b/apt/progress/text.py
@@ -157,11 +157,10 @@ class AcquireProgress(base.AcquireProgress, TextProgress):
 
         shown = False
         tval = '%i%%' % percent
-
         end = ""
         if self.current_cps:
-            eta = int(float(self.total_bytes - self.current_bytes) /
-                      self.current_cps)
+            eta = long(float(self.total_bytes - self.current_bytes) /
+                        self.current_cps)
             end = " %sB/s %s" % (apt_pkg.size_to_str(self.current_cps),
                                  apt_pkg.time_to_str(eta))