Todo
This should be split and cleaned up a bit.
Status:
Normally, apt checkes the package cache after every modification for packages which are automatically installed but on which no package depends anymore (it collects the package garbage).
Using ActionGroups you can turn this off and therefore make your code much faster.
Initialize it using apt_pkg.GetPkgActionGroup(), eg:
apt_pkg.GetPkgActionGroup(depcache)
The Configuration objects store the configuration of apt.
Return the value for the given key key. This is the same as Configuration.get().
If key does not exist, return default.
Return the filename hold by the configuration at key. This formats the filename correctly and supports the Dir:: stuff in the configuration.
If key does not exist, return default.
Return the absolute path to the directory specified in key. A trailing slash is appended.
If key does not exist, return default.
Return the integer value stored at key.
If key does not exist, return default.
Return the boolean value stored at key. This returns an integer, but it should be treated like True/False.
If key does not exist, return default.
List all items at key. Normally, return the keys at the top level, eg. APT, Dir, etc.
Use key to specify a key of which the childs will be returned.
The pkgCache class prov
Update the package cache.
The parameter progress points to an apt.progress.FetchProgress() object.
The parameter list refers to an object as returned by apt_pkg.GetPkgSourceList().
Todo
Seems to be some mixture of versions and pkgFile.
A PackageFile represents a Packages file, eg. /var/lib/dpkg/status.
Whether the file has no source from which it can be updated. In such a case, the value is 1; else 0. /var/lib/dpkg/status is 0 for example.
Example:
for pkgfile in cache.FileList:
if pkgfile.NotSource:
print 'The file %s has no source.' % pkgfile.FileName
#!/usr/bin/python
import apt_pkg
def main():
"""Example for PackageFile()"""
apt_pkg.init()
cache = apt_pkg.GetCache()
for pkgfile in cache.FileList:
print 'Package-File:', pkgfile.FileName
print 'Index-Type:', pkgfile.IndexType # 'Debian Package Index'
if pkgfile.NotSource:
print 'Source: None'
else:
if pkgfile.Site:
# There is a source, and a site, print the site
print 'Source:', pkgfile.Site
else:
# It seems to be a local repository
print 'Source: Local package file'
if pkgfile.NotAutomatic:
# The system won't be updated automatically (eg. experimental)
print 'Automatic: No'
else:
print 'Automatic: Yes'
print
if __name__ == '__main__':
main()
The pkgCache::Package objects are an interface to package specific features.
Attributes:
A list of packages providing this package. More detailed, this is a list of tuples (str:pkgname, ????, Version).
If you want to check for check for virtual packages, the expression pkg.ProvidesList and not pkg.VersionList helps you. It detects if the package is provided by something else and is not available as a real package.
States:
The state we want it to be, ie. if you mark a package for installation, this is apt_pkg.SelStateInstall.
See Select states for a list of available states.
The state the currently installed version is in. This is normally apt_pkg.InstStateOK, unless the installation failed.
See Installed states for a list of available states.
Flags:
#!/usr/bin/python
"""Example for packages. Print all essential and important packages"""
import apt_pkg
def main():
"""Main."""
apt_pkg.InitConfig()
apt_pkg.InitSystem()
cache = apt_pkg.GetCache()
print "Essential packages:"
for pkg in cache.Packages:
if pkg.Essential:
print " ", pkg.Name
print "Important packages:"
for pkg in cache.Packages:
if pkg.Important:
print " ", pkg.Name
if __name__ == "__main__":
main()
The version object contains all information related to a specific package version.
A dictionary of dependencies. The key specifies the type of the dependency (‘Depends’, ‘Recommends’, etc.).
The value is a list, containing items which refer to the or-groups of dependencies. Each of these or-groups is itself a list, containing tuples like (‘pkgname’, ‘version’, ‘relation’) for each or-choice.
An example return value for a package with a ‘Depends: python (>= 2.4)’ would be:
{'Depends': [
[
('python', '2.4', '>=')
]
]
}
The same for a dependency on A (>= 1) | B (>= 2):
{'Depends': [
[
('A', '1', '>='),
('B', '2', '>='),
]
]
}
The integer representation of the priority. This can be used to speed up comparisons a lot, compared to Version.PriorityStr.
The values are defined in the apt_pkg extension, see Priorities for more information.
Represent a dependency from one package to another one.
A list of Version objects which satisfy the dependency, and do not conflict with already installed ones.
From my experience, if you use this method to select the target version, it is the best to select the last item unless any of the other candidates is already installed. This leads to results being very close to the normal package installation.
With the help of Dependency.AllTargets(), you can easily find all packages with broken dependencies:
#!/usr/bin/python
"""Check the archive for missing dependencies"""
import apt_pkg
def fmt_dep(dep):
"""Format a Dependency object [of apt_pkg] as a string."""
ret = dep.TargetPkg.Name
if dep.TargetVer:
ret += " (%s %s)" % (dep.CompType, dep.TargetVer)
return ret
def check_version(pkgver):
"""Check the version of the package"""
missing = []
for or_group in pkgver.DependsList.get("Pre-Depends", []) + \
pkgver.DependsList.get("Depends", []):
if not any(dep.AllTargets() for dep in or_group):
# If none of the or-choices can be satisfied, add it to missing
missing.append(or_group)
if missing:
print "Package:", pkgver.ParentPkg.Name
print "Version:", pkgver.VerStr
print "Missing:",
print ", ".join(" | ".join(fmt_dep(dep) for dep in or_group)
for or_group in missing)
print
def main():
"""The main function."""
apt_pkg.InitConfig()
apt_pkg.InitSystem()
cache = apt_pkg.GetCache()
for pkg in sorted(cache.Packages, key=lambda pkg: pkg.Name):
# pkg is from a list of packages, sorted by name.
for version in pkg.VersionList:
# Check every version
for pfile, _ in version.FileList:
if (pfile.Origin == "Debian" and pfile.Component == "main" and
pfile.Archive == "unstable"):
# We only want packages from Debian unstable main.
check_version(version)
break
if __name__ == "__main__":
main()
Represent the description of the package.
The pkgDepCache object contains various methods to manipulate the cache, to install packages, to remove them, and much more.
Apply all the changes made.
The parameter fprogress has to be set to an instance of apt.progress.FetchProgress or one of its subclasses.
The parameter iprogress has to be set to an instance of apt.progress.InstallProgress or one of its subclasses.
Return the candidate version of the package, ie. the version that would be installed normally.
The parameter pkg refers to an Package object, available using the pkgCache.
This method returns a Version object.
Perform an upgrade. More detailed, this marks all the upgradable packages for upgrade. You still need to call pkgDepCache.Commit() for the changes to apply.
To perform a dist-upgrade, the optional parameter distUpgrade has to be set to True.
Go over the entire set of packages and try to keep each package marked for upgrade. If a conflict is generated then the package is restored.
Todo
Explain better..
Mark the Package pkg for install.
If autoInst is True, the dependencies of the package will be installed as well. This is the default.
If fromUser is True, the package will be marked as manually installed. This is the default.
Return 1 if the package is upgradable.
The package can be upgraded by calling pkgDepCache.MarkInstall().
Class, as returned by apt_pkg.GetPackageManager().
Add all the selected packages to the Acquire() object fetcher.
The parameter list refers to a PkgSourceList() object, as returned by apt_pkg.GetPkgSourceList().
The parameter records refers to a pkgRecords() object, as returned by apt_pkg.GetPkgRecords().
A constant for checking whether the the result is ‘completed’.
Compare it against the return value of PkgManager.GetArchives() or PkgManager.DoInstall().
A constant for checking whether the the result is ‘failed’.
Compare it against the return value of PkgManager.GetArchives() or PkgManager.DoInstall().
A constant for checking whether the the result is ‘incomplete’.
Compare it against the return value of PkgManager.GetArchives() or PkgManager.DoInstall().
Provide access to the packages records. This provides very useful attributes for fast (convient) access to some fields of the record.
See apt_pkg.GetPkgRecords() for initialization.
Change the actual package to the package given by the verfile_iter.
The parameter verfile_iter refers to a tuple consisting of (PackageFile(), int: index), as returned by various attributes, including Version.FileList.
Example (shortened):
cand = depcache.GetCandidateVer(cache['python-apt'])
records.Lookup(cand.FileList[0])
# Now you can access the record
print records.SourcePkg # == python-apt
Return the SHA256 hashsum of the package. This refers to the field ‘SHA256’ in the raw record.
New in version 0.7.9.
Return the whole record as a string. If you want to access fields of the record not available as an attribute, you can use apt_pkg.ParseSection() to parse the record and access the field name.
Example:
section = apt_pkg.ParseSection(records.Record)
print section['SHA256']
This represents the entries in the Sources files, ie. the dsc files of the source packages.
Note
If the Lookup failed, because no package could be found, no error is raised. Instead, the attributes listed below are simply not existing anymore (same applies when no Lookup has been made, or when it has been restarted).
Lookup the record for the package named pkgname. To access all available records, you need to call it multiple times.
Imagine a package P with two versions X, Y. The first Lookup(P) would set the record to version X and the second Lookup(P) to version Y.
Restart the lookup.
Imagine a package P with two versions X, Y. The first Lookup(P) would set the record to version X and the second Lookup(P) to version Y.
If you now call Restart(), the internal position will be cleared. Now you can call Lookup(P) again to move to X.
The whole record, as a string. You can use apt_pkg.ParseSection() if you need to parse it.
You need to parse the record if you want to access fields not available via the attributes, eg. ‘Standards-Version’
Return the list of Build dependencies, as (str: package, str: version, int: op, int: type).
Value | Meaning |
---|---|
0x0 | No Operation (no versioned build dependency) |
0x10 | (or) - this will be added to the other values
|
0x1 | <= (less than or equal) |
0x2 | >= (greater than or equal) |
0x3 | << (less than) |
0x4 | >> (greater than) |
0x5 | == (equal) |
0x6 | != (not equal) |
Value | Meaning |
---|---|
0 | Build-Depends |
1 | Build-Depends-Indep |
2 | Build-Conflicts |
3 | Build-Conflicts-Indep |
Example: In the following content, we will imagine a build-dependency:
Build-Depends: A (>= 1) | B (>= 1), C
This results in:
[('A', '1', 18, 0), # 18 = 16 + 2 = 0x10 + 0x2
('B', '1', 2, 0),
('C', '', 0, 0)]
This is not the same as returned by apt_pkg.ParseSrcDepends().
This is for /etc/apt/sources.list.
The problem resolver helps when there are problems in the package selection. An example is a package which conflicts with another, already installed package.
An object which represents a typical debian control file. Can be used for Packages, Sources, control, Release, etc.
Use apt_pkg.ParseTagFile() to parse a file.
Represent a single section of a debian control file.