Upload folder using huggingface_hub

.gitattributes

@@ -44,3 +44,4 @@ LLaMA-Factory/data/oaast_rm.json filter=lfs diff=lfs merge=lfs -text
 LLaMA-Factory/data/oaast_sft.json filter=lfs diff=lfs merge=lfs -text
 sample_data/mnist_test.csv filter=lfs diff=lfs merge=lfs -text
 sample_data/mnist_train_small.csv filter=lfs diff=lfs merge=lfs -text
+build/lib.linux-x86_64-cpython-310/apt_pkg.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

.gitlab-ci.yml

@@ -0,0 +1,35 @@
+image: ubuntu:jammy
+variables:
+  DEBIAN_FRONTEND: noninteractive
+
+typing:
+  script:
+  - apt update
+  - apt install -q -y python3-pip
+  - python3 -m pip install -U mypy==0.942
+  - env MYPYPATH=$PWD/typehinting/ mypy --strict ./apt
+
+pep8:
+  script:
+  - apt update
+  - apt install -q -y pycodestyle
+  - env python3 tests/testmanual_pycodestyle.py
+
+test:
+  script:
+  - apt update
+  - apt build-dep -q -y ./
+  - dpkg-buildpackage
+  artifacts:
+    paths:
+    - build/sphinx/html/
+
+pages:
+  stage: deploy
+  script:
+  - mv build/sphinx/html/ public
+  artifacts:
+    paths:
+    - public
+  rules:
+  - if: '$CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH'

.travis.yml

@@ -0,0 +1,14 @@
+language: cpp
+cache: ccache
+sudo: required
+services:
+  - docker
+env:
+ - DISTRO=ubuntu:eoan
+install:
+ - sed -i -e "s#1000#$(id -u)#g" -e "s#debian:testing#$DISTRO#g" Dockerfile
+ - docker build --tag=apt-ci .
+script:
+ - docker run --rm -w $PWD -v $HOME/.ccache:$HOME/.ccache -v $PWD:$PWD --user=travis apt-ci env ./debian/rules build-arch
+ - docker run --rm -w $PWD -v $PWD:$PWD --user=travis apt-ci env python3 tests/testmanual_pycodestyle.py
+ - docker run --rm -w $PWD -v $PWD:$PWD --user=travis apt-ci env MYPYPATH=$PWD/typehinting/ mypy ./apt

AUTHORS

@@ -0,0 +1,7 @@
+jgg Jason Gunthorpe <[email protected]>
+mdz Matt Zimmerman <[email protected]>
+mvo Michael Vogt <[email protected]>
+Michiel Sikkes <[email protected]>
+Sebastian Heinlein <[email protected]>
+Sean Wheller   <[email protected]>
+Julian Andres Klode <[email protected]>

COPYING.GPL

@@ -0,0 +1,340 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+                       59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	    How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) 19yy  <name of author>
+
+    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
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) 19yy name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.

Dockerfile

@@ -0,0 +1,11 @@
+FROM debian:testing
+COPY . /tmp
+WORKDIR /tmp
+RUN sed -i s#://deb.debian.org#://cdn-fastly.deb.debian.org# /etc/apt/sources.list \
+    && apt-get update \
+    && adduser --home /home/travis travis --quiet --disabled-login --gecos "" --uid 1000 \
+    && env DEBIAN_FRONTEND=noninteractive apt-get build-dep -y /tmp \
+    && env DEBIAN_FRONTEND=noninteractive apt-get install -y ccache python3-pip \
+    && python3 -m pip install -U mypy \
+    && rm -r /tmp/* \
+    && apt-get clean

README.md

@@ -1,17 +1,49 @@
----
-license: mit
-language:
-- it
-- en
-- fr
-- es
-- de
-- zh
-metrics:
-- code_eval
-- bleurt
-tags:
-- text-generation-inference
-library_name: flair
-pipeline_tag: text-generation
----
+# Python-apt is a wrapper to use features of apt from python.
+
+It contains the following modules:
+
+## C++ Wrapper:
+
+* apt_pkg - access to libapt-pkg (wrapper to the lowlevel c++ code)
+* apt_inst - access to libapt-inst (wrapper to the lowlevel c++ code)
+
+## Python module:
+
+* apt - high level python interface build on top of apt_pkg, apt_inst
+* aptsources - high level manipulation of sources.list
+
+
+# Development
+
+## Building
+
+To build python-apt run:
+```
+$ python setup.py build
+```
+You may need to install the build-dependencies via:
+```
+$ sudo apt build-dep ./
+```
+first.
+
+## Running the tests
+
+Run the tests with:
+```
+$ python tests/test_all.py
+$ python3 tests/test_all.py
+```
+
+## Running mypy:
+
+To check if the "apt" python module is mypy clean, run:
+```
+$ MYPYPATH=./typehinting/ mypy ./apt
+```
+
+To use the annotation with your source code, run:
+```
+$ MYPYPATH=/usr/lib/python3/dist-packages/apt mypy ./my-program
+```
+(adjust from python3 to python2.7 if you run there).

TODO

@@ -0,0 +1,4 @@
+* aptsources:
+ - make the distro detection in sources.list more clever by using the
+   origin informaton to avoid adding full uris to (unofficial/internal)
+   mirrors

apt/__init__.py

@@ -0,0 +1,38 @@
+#  Copyright (c) 2005-2009 Canonical
+#
+#  Author: Michael Vogt <[email protected]>
+#
+#  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
+# import the core of apt_pkg
+"""High-Level Interface for working with apt."""
+from __future__ import print_function
+
+import apt_pkg
+
+# import some fancy classes
+from apt.package import Package as Package, Version as Version
+from apt.cache import Cache as Cache, ProblemResolver as ProblemResolver
+Cache  # pyflakes
+ProblemResolver  # pyflakes
+Version  # pyflakes
+from apt.cdrom import Cdrom as Cdrom
+
+# init the package system, but do not re-initialize config
+if "APT" not in apt_pkg.config:
+    apt_pkg.init_config()
+apt_pkg.init_system()
+
+__all__ = ['Cache', 'Cdrom', 'Package']

apt/auth.py

@@ -0,0 +1,309 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+# auth - authentication key management
+#
+#  Copyright (c) 2004 Canonical
+#  Copyright (c) 2012 Sebastian Heinlein
+#
+#  Author: Michael Vogt <[email protected]>
+#          Sebastian Heinlein <[email protected]>
+#
+#  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
+"""Handle GnuPG keys used to trust signed repositories."""
+
+from __future__ import print_function
+
+import errno
+import os
+import os.path
+import shutil
+import subprocess
+import sys
+import tempfile
+
+import apt_pkg
+from apt_pkg import gettext as _
+
+from typing import List, Optional, Tuple
+
+
+class AptKeyError(Exception):
+    pass
+
+
+class AptKeyIDTooShortError(AptKeyError):
+    """Internal class do not rely on it."""
+
+
+class TrustedKey(object):
+
+    """Represents a trusted key."""
+
+    def __init__(self, name, keyid, date):
+        # type: (str, str, str) -> None
+        self.raw_name = name
+        # Allow to translated some known keys
+        self.name = _(name)
+        self.keyid = keyid
+        self.date = date
+
+    def __str__(self):
+        # type: () -> str
+        return "%s\n%s %s" % (self.name, self.keyid, self.date)
+
+
+def _call_apt_key_script(*args, **kwargs):
+    # type: (str, Optional[str]) -> str
+    """Run the apt-key script with the given arguments."""
+    conf = None
+    cmd = [apt_pkg.config.find_file("Dir::Bin::Apt-Key", "/usr/bin/apt-key")]
+    cmd.extend(args)
+    env = os.environ.copy()
+    env["LANG"] = "C"
+    env["APT_KEY_DONT_WARN_ON_DANGEROUS_USAGE"] = "1"
+    try:
+        if apt_pkg.config.find_dir("Dir") != "/":
+            # If the key is to be installed into a chroot we have to export the
+            # configuration from the chroot to the apt-key script by using
+            # a temporary APT_CONFIG file. The apt-key script uses apt-config
+            # shell internally
+            conf = tempfile.NamedTemporaryFile(
+                prefix="apt-key", suffix=".conf")
+            conf.write(apt_pkg.config.dump().encode("UTF-8"))
+            conf.flush()
+            env["APT_CONFIG"] = conf.name
+        proc = subprocess.Popen(cmd, env=env, universal_newlines=True,
+                                stdin=subprocess.PIPE,
+                                stdout=subprocess.PIPE,
+                                stderr=subprocess.PIPE)
+
+        stdin = kwargs.get("stdin", None)
+
+        output, stderr = proc.communicate(stdin)  # type: str, str
+
+        if proc.returncode:
+            raise AptKeyError(
+                "The apt-key script failed with return code %s:\n"
+                "%s\n"
+                "stdout: %s\n"
+                "stderr: %s" % (
+                    proc.returncode, " ".join(cmd), output, stderr))
+        elif stderr:
+            sys.stderr.write(stderr)    # Forward stderr
+
+        return output.strip()
+    finally:
+        if conf is not None:
+            conf.close()
+
+
+def add_key_from_file(filename):
+    # type: (str) -> None
+    """Import a GnuPG key file to trust repositores signed by it.
+
+    Keyword arguments:
+    filename -- the absolute path to the public GnuPG key file
+    """
+    if not os.path.abspath(filename):
+        raise AptKeyError("An absolute path is required: %s" % filename)
+    if not os.access(filename, os.R_OK):
+        raise AptKeyError("Key file cannot be accessed: %s" % filename)
+    _call_apt_key_script("add", filename)
+
+
+def add_key_from_keyserver(keyid, keyserver):
+    # type: (str, str) -> None
+    """Import a GnuPG key file to trust repositores signed by it.
+
+    Keyword arguments:
+    keyid -- the long keyid (fingerprint) of the key, e.g.
+             A1BD8E9D78F7FE5C3E65D8AF8B48AD6246925553
+    keyserver -- the URL or hostname of the key server
+    """
+    tmp_keyring_dir = tempfile.mkdtemp()
+    try:
+        _add_key_from_keyserver(keyid, keyserver, tmp_keyring_dir)
+    except Exception:
+        raise
+    finally:
+        # We are racing with gpg when removing sockets, so ignore
+        # failure to delete non-existing files.
+        def onerror(func, path, exc_info):
+            # type: (object, str, Tuple[type, Exception, object]) -> None
+            if (isinstance(exc_info[1], OSError) and
+                exc_info[1].errno == errno.ENOENT):
+                return
+            raise
+
+        shutil.rmtree(tmp_keyring_dir, onerror=onerror)
+
+
+def _add_key_from_keyserver(keyid, keyserver, tmp_keyring_dir):
+    # type: (str, str, str) -> None
+    if len(keyid.replace(" ", "").replace("0x", "")) < (160 / 4):
+        raise AptKeyIDTooShortError(
+            "Only fingerprints (v4, 160bit) are supported")
+    # create a temp keyring dir
+    tmp_secret_keyring = os.path.join(tmp_keyring_dir, "secring.gpg")
+    tmp_keyring = os.path.join(tmp_keyring_dir, "pubring.gpg")
+    # default options for gpg
+    gpg_default_options = [
+        "gpg",
+        "--no-default-keyring", "--no-options",
+        "--homedir", tmp_keyring_dir,
+    ]
+    # download the key to a temp keyring first
+    res = subprocess.call(gpg_default_options + [
+        "--secret-keyring", tmp_secret_keyring,
+        "--keyring", tmp_keyring,
+        "--keyserver", keyserver,
+        "--recv", keyid,
+    ])
+    if res != 0:
+        raise AptKeyError("recv from '%s' failed for '%s'" % (
+            keyserver, keyid))
+    # FIXME:
+    # - with gnupg 1.4.18 the downloaded key is actually checked(!),
+    #   i.e. gnupg will not import anything that the server sends
+    #   into the keyring, so the below checks are now redundant *if*
+    #   gnupg 1.4.18 is used
+
+    # now export again using the long key id (to ensure that there is
+    # really only this one key in our keyring) and not someone MITM us
+    tmp_export_keyring = os.path.join(tmp_keyring_dir, "export-keyring.gpg")
+    res = subprocess.call(gpg_default_options + [
+        "--keyring", tmp_keyring,
+        "--output", tmp_export_keyring,
+        "--export", keyid,
+    ])
+    if res != 0:
+        raise AptKeyError("export of '%s' failed", keyid)
+    # now verify the fingerprint, this is probably redundant as we
+    # exported by the fingerprint in the previous command but its
+    # still good paranoia
+    output = subprocess.Popen(
+        gpg_default_options + [
+            "--keyring", tmp_export_keyring,
+            "--fingerprint",
+            "--batch",
+            "--fixed-list-mode",
+            "--with-colons",
+        ],
+        stdout=subprocess.PIPE,
+        universal_newlines=True).communicate()[0]
+    got_fingerprint = None
+    for line in output.splitlines():
+        if line.startswith("fpr:"):
+            got_fingerprint = line.split(":")[9]
+            # stop after the first to ensure no subkey trickery
+            break
+    # strip the leading "0x" is there is one and uppercase (as this is
+    # what gnupg is using)
+    signing_key_fingerprint = keyid.replace("0x", "").upper()
+    if got_fingerprint != signing_key_fingerprint:
+        # make the error match what gnupg >= 1.4.18 will output when
+        # it checks the key itself before importing it
+        raise AptKeyError(
+            "recv from '%s' failed for '%s'" % (
+                keyserver, signing_key_fingerprint))
+    # finally add it
+    add_key_from_file(tmp_export_keyring)
+
+
+def add_key(content):
+    # type: (str) -> None
+    """Import a GnuPG key to trust repositores signed by it.
+
+    Keyword arguments:
+    content -- the content of the GnuPG public key
+    """
+    _call_apt_key_script("adv", "--quiet", "--batch",
+                         "--import", "-", stdin=content)
+
+
+def remove_key(fingerprint):
+    # type: (str) -> None
+    """Remove a GnuPG key to no longer trust repositores signed by it.
+
+    Keyword arguments:
+    fingerprint -- the fingerprint identifying the key
+    """
+    _call_apt_key_script("rm", fingerprint)
+
+
+def export_key(fingerprint):
+    # type: (str) -> str
+    """Return the GnuPG key in text format.
+
+    Keyword arguments:
+    fingerprint -- the fingerprint identifying the key
+    """
+    return _call_apt_key_script("export", fingerprint)
+
+
+def update():
+    # type: () -> str
+    """Update the local keyring with the archive keyring and remove from
+    the local keyring the archive keys which are no longer valid. The
+    archive keyring is shipped in the archive-keyring package of your
+    distribution, e.g. the debian-archive-keyring package in Debian.
+    """
+    return _call_apt_key_script("update")
+
+
+def net_update():
+    # type: () -> str
+    """Work similar to the update command above, but get the archive
+    keyring from an URI instead and validate it against a master key.
+    This requires an installed wget(1) and an APT build configured to
+    have a server to fetch from and a master keyring to validate. APT
+    in Debian does not support this command and relies on update
+    instead, but Ubuntu's APT does.
+    """
+    return _call_apt_key_script("net-update")
+
+
+def list_keys():
+    # type: () -> List[TrustedKey]
+    """Returns a list of TrustedKey instances for each key which is
+    used to trust repositories.
+    """
+    # The output of `apt-key list` is difficult to parse since the
+    # --with-colons parameter isn't user
+    output = _call_apt_key_script("adv", "--with-colons", "--batch",
+                                  "--fixed-list-mode", "--list-keys")
+    res = []
+    for line in output.split("\n"):
+        fields = line.split(":")
+        if fields[0] == "pub":
+            keyid = fields[4]
+        if fields[0] == "uid":
+            uid = fields[9]
+            creation_date = fields[5]
+            key = TrustedKey(uid, keyid, creation_date)
+            res.append(key)
+    return res
+
+
+if __name__ == "__main__":
+    # Add some known keys we would like to see translated so that they get
+    # picked up by gettext
+    lambda: _("Ubuntu Archive Automatic Signing Key <[email protected]>")
+    lambda: _("Ubuntu CD Image Automatic Signing Key <[email protected]>")
+
+    apt_pkg.init()
+    for trusted_key in list_keys():
+        print(trusted_key)

apt/cache.py

@@ -0,0 +1,1038 @@
+# cache.py - apt cache abstraction
+#
+#  Copyright (c) 2005-2009 Canonical
+#
+#  Author: Michael Vogt <[email protected]>
+#
+#  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
+
+from __future__ import print_function
+
+import fnmatch
+import os
+import warnings
+import weakref
+
+
+from typing import (Any, Callable, Dict, Iterator, List, Optional,
+                    Set, Tuple, Union, cast, KeysView)
+
+import apt_pkg
+from apt.package import Package, Version
+import apt.progress.text
+from apt.progress.base import AcquireProgress, InstallProgress, OpProgress
+
+
+class FetchCancelledException(IOError):
+    """Exception that is thrown when the user cancels a fetch operation."""
+
+
+class FetchFailedException(IOError):
+    """Exception that is thrown when fetching fails."""
+
+
+class UntrustedException(FetchFailedException):
+    """Exception that is thrown when fetching fails for trust reasons"""
+
+
+class LockFailedException(IOError):
+    """Exception that is thrown when locking fails."""
+
+
+class CacheClosedException(Exception):
+    """Exception that is thrown when the cache is used after close()."""
+
+
+class _WrappedLock(object):
+    """Wraps an apt_pkg.FileLock to raise LockFailedException.
+
+    Initialized using a directory path."""
+
+    def __init__(self, path):
+        # type: (str) -> None
+        self._path = path
+        self._lock = apt_pkg.FileLock(os.path.join(path, "lock"))
+
+    def __enter__(self):
+        # type: () -> None
+        try:
+            return self._lock.__enter__()
+        except apt_pkg.Error as e:
+            raise LockFailedException(("Failed to lock directory %s: %s") %
+                                       (self._path, e))
+
+    def __exit__(self, typ, value, traceback):
+        # type: (object, object, object) -> None
+        return self._lock.__exit__(typ, value, traceback)
+
+
+class Cache(object):
+    """Dictionary-like package cache.
+
+    The APT cache file contains a hash table mapping names of binary
+    packages to their metadata. A Cache object is the in-core
+    representation of the same. It provides access to APTs idea of the
+    list of available packages.
+
+    The cache can be used like a mapping from package names to Package
+    objects (although only getting items is supported).
+
+    Keyword arguments:
+    progress -- a OpProgress object,
+    rootdir  -- an alternative root directory. if that is given the system
+    sources.list and system lists/files are not read, only file relative
+    to the given rootdir,
+    memonly  -- build the cache in memory only.
+
+
+    .. versionchanged:: 1.0
+
+        The cache now supports package names with special architecture
+        qualifiers such as :all and :native. It does not export them
+        in :meth:`keys()`, though, to keep :meth:`keys()` a unique set.
+    """
+
+    def __init__(self, progress=None, rootdir=None, memonly=False):
+        # type: (Optional[OpProgress], Optional[str], bool) -> None
+        self._cache = cast(apt_pkg.Cache, None)  # type: apt_pkg.Cache
+        self._depcache = cast(apt_pkg.DepCache, None)  # type: apt_pkg.DepCache
+        self._records = cast(apt_pkg.PackageRecords, None)  # type: apt_pkg.PackageRecords # noqa
+        self._list = cast(apt_pkg.SourceList, None)  # type: apt_pkg.SourceList
+        self._callbacks = {}  # type: Dict[str, List[Union[Callable[..., None],str]]] # noqa
+        self._callbacks2 = {}  # type: Dict[str, List[Tuple[Callable[..., Any], Tuple[Any, ...], Dict[Any,Any]]]] # noqa
+        self._weakref = weakref.WeakValueDictionary()  # type: weakref.WeakValueDictionary[str, apt.Package] # noqa
+        self._weakversions = weakref.WeakSet()  # type: weakref.WeakSet[Version] # noqa
+        self._changes_count = -1
+        self._sorted_set = None  # type: Optional[List[str]]
+
+        self.connect("cache_post_open", "_inc_changes_count")
+        self.connect("cache_post_change", "_inc_changes_count")
+        if memonly:
+            # force apt to build its caches in memory
+            apt_pkg.config.set("Dir::Cache::pkgcache", "")
+        if rootdir:
+            rootdir = os.path.abspath(rootdir)
+            if os.path.exists(rootdir + "/etc/apt/apt.conf"):
+                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.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",
+                               rootdir + "/var/lib/dpkg/status")
+            # also set dpkg to the rootdir path so that its called for the
+            # --print-foreign-architectures call
+            apt_pkg.config.set("Dir::bin::dpkg",
+                               os.path.join(rootdir, "usr", "bin", "dpkg"))
+            # create required dirs/files when run with special rootdir
+            # automatically
+            self._check_and_create_required_dirs(rootdir)
+            # Call InitSystem so the change to Dir::State::Status is actually
+            # recognized (LP: #320665)
+            apt_pkg.init_system()
+
+        # Prepare a lock object (context manager for archive lock)
+        archive_dir = apt_pkg.config.find_dir("Dir::Cache::Archives")
+        self._archive_lock = _WrappedLock(archive_dir)
+
+        self.open(progress)
+
+    def fix_broken(self):
+        # type: () -> None
+        """Fix broken packages."""
+        self._depcache.fix_broken()
+
+    def _inc_changes_count(self):
+        # type: () -> None
+        """Increase the number of changes"""
+        self._changes_count += 1
+
+    def _check_and_create_required_dirs(self, rootdir):
+        # type: (str) -> None
+        """
+        check if the required apt directories/files are there and if
+        not create them
+        """
+        files = [
+            "/var/lib/dpkg/status",
+            "/etc/apt/sources.list",
+        ]
+        dirs = [
+            "/var/lib/dpkg",
+            "/etc/apt/",
+            "/var/cache/apt/archives/partial",
+            "/var/lib/apt/lists/partial",
+        ]
+        for d in dirs:
+            if not os.path.exists(rootdir + d):
+                #print "creating: ", rootdir + d
+                os.makedirs(rootdir + d)
+        for f in files:
+            if not os.path.exists(rootdir + f):
+                open(rootdir + f, "w").close()
+
+    def _run_callbacks(self, name):
+        # type: (str) -> None
+        """ internal helper to run a callback """
+        if name in self._callbacks:
+            for callback in self._callbacks[name]:
+                if callback == '_inc_changes_count':
+                    self._inc_changes_count()
+                else:
+                    callback()  # type: ignore
+
+        if name in self._callbacks2:
+            for callback, args, kwds in self._callbacks2[name]:
+                callback(self, *args, **kwds)
+
+    def open(self, progress=None):
+        # type: (Optional[OpProgress]) -> None
+        """ Open the package cache, after that it can be used like
+            a dictionary
+        """
+        if progress is None:
+            progress = apt.progress.base.OpProgress()
+        # close old cache on (re)open
+        self.close()
+        self.op_progress = progress
+        self._run_callbacks("cache_pre_open")
+
+        self._cache = apt_pkg.Cache(progress)
+        self._depcache = apt_pkg.DepCache(self._cache)
+        self._records = apt_pkg.PackageRecords(self._cache)
+        self._list = apt_pkg.SourceList()
+        self._list.read_main_list()
+        self._sorted_set = None
+        self.__remap()
+
+        self._have_multi_arch = len(apt_pkg.get_architectures()) > 1
+
+        progress.done()
+        self._run_callbacks("cache_post_open")
+
+    def __remap(self):
+        # type: () -> None
+        """Called after cache reopen() to relocate to new cache.
+
+        Relocate objects like packages and versions from the old
+        underlying cache to the new one.
+        """
+        for key in list(self._weakref.keys()):
+            try:
+                pkg = self._weakref[key]
+            except KeyError:
+                continue
+
+            try:
+                pkg._pkg = self._cache[pkg._pkg.name, pkg._pkg.architecture]
+            except LookupError:
+                del self._weakref[key]
+
+        for ver in list(self._weakversions):
+            # Package has been reseated above, reseat version
+            for v in ver.package._pkg.version_list:
+                # Requirements as in debListParser::SameVersion
+                if (v.hash == ver._cand.hash and
+                    (v.size == 0 or ver._cand.size == 0 or
+                     v.size == ver._cand.size) and
+                    v.multi_arch == ver._cand.multi_arch and
+                    v.ver_str == ver._cand.ver_str):
+                    ver._cand = v
+                    break
+            else:
+                self._weakversions.remove(ver)
+
+    def close(self):
+        # type: () -> None
+        """ Close the package cache """
+        # explicitely free the FDs that _records has open
+        del self._records
+        self._records = cast(apt_pkg.PackageRecords, None)
+
+    def __enter__(self):
+        # type: () -> Cache
+        """ Enter the with statement """
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        # type: (object, object, object) -> None
+        """ Exit the with statement """
+        self.close()
+
+    def __getitem__(self, key):
+        # type: (object) -> Package
+        """ look like a dictionary (get key) """
+        try:
+            key = str(key)
+            rawpkg = self._cache[key]
+        except KeyError:
+            raise KeyError('The cache has no package named %r' % key)
+
+        # It might be excluded due to not having a version or something
+        if not self.__is_real_pkg(rawpkg):
+            raise KeyError('The cache has no package named %r' % key)
+
+        pkg = self._rawpkg_to_pkg(rawpkg)
+
+        return pkg
+
+    def get(self, key, default=None):
+        # type: (object, object) -> Any
+        """Return *self*[*key*] or *default* if *key* not in *self*.
+
+        .. versionadded:: 1.1
+        """
+        try:
+            return self[key]
+        except KeyError:
+            return default
+
+    def _rawpkg_to_pkg(self, rawpkg):
+        # type: (apt_pkg.Package) -> Package
+        """Returns the apt.Package object for an apt_pkg.Package object.
+
+        .. versionadded:: 1.0.0
+        """
+        fullname = rawpkg.get_fullname(pretty=True)
+
+        return self._weakref.setdefault(fullname, Package(self, rawpkg))
+
+    def __iter__(self):
+        # type: () -> Iterator[Package]
+        # We iterate sorted over package names here. With this we read the
+        # package lists linearly if we need to access the package records,
+        # instead of having to do thousands of random seeks; the latter
+        # is disastrous if we use compressed package indexes, and slower than
+        # necessary for uncompressed indexes.
+        for pkgname in self.keys():
+            pkg = Package(self, self._cache[pkgname])
+            yield self._weakref.setdefault(pkgname, pkg)
+
+    def __is_real_pkg(self, rawpkg):
+        # type: (apt_pkg.Package) -> bool
+        """Check if the apt_pkg.Package provided is a real package."""
+        return rawpkg.has_versions
+
+    def has_key(self, key):
+        # type: (object) -> bool
+        return key in self
+
+    def __contains__(self, key):
+        # type: (object) -> bool
+        try:
+            return self.__is_real_pkg(self._cache[str(key)])
+        except KeyError:
+            return False
+
+    def __len__(self):
+        # type: () -> int
+        return len(self.keys())
+
+    def keys(self):
+        # type: () -> List[str]
+        if self._sorted_set is None:
+            self._sorted_set = sorted(p.get_fullname(pretty=True)
+                                      for p in self._cache.packages
+                                        if self.__is_real_pkg(p))
+        return list(self._sorted_set)  # We need a copy here, caller may modify
+
+    def get_changes(self):
+        # type: () -> List[Package]
+        """ Get the marked changes """
+        changes = []
+        marked_keep = self._depcache.marked_keep
+        for rawpkg in self._cache.packages:
+            if not marked_keep(rawpkg):
+                changes.append(self._rawpkg_to_pkg(rawpkg))
+        return changes
+
+    def upgrade(self, dist_upgrade=False):
+        # type: (bool) -> None
+        """Upgrade all packages.
+
+        If the parameter *dist_upgrade* is True, new dependencies will be
+        installed as well (and conflicting packages may be removed). The
+        default value is False.
+        """
+        self.cache_pre_change()
+        self._depcache.upgrade(dist_upgrade)
+        self.cache_post_change()
+
+    @property
+    def required_download(self):
+        # type: () -> int
+        """Get the size of the packages that are required to download."""
+        if self._records is None:
+            raise CacheClosedException(
+                "Cache object used after close() called")
+        pm = apt_pkg.PackageManager(self._depcache)
+        fetcher = apt_pkg.Acquire()
+        pm.get_archives(fetcher, self._list, self._records)
+        return fetcher.fetch_needed
+
+    @property
+    def required_space(self):
+        # type: () -> int
+        """Get the size of the additional required space on the fs."""
+        return self._depcache.usr_size
+
+    @property
+    def req_reinstall_pkgs(self):
+        # type: () -> Set[str]
+        """Return the packages not downloadable packages in reqreinst state."""
+        reqreinst = set()
+        get_candidate_ver = self._depcache.get_candidate_ver
+        states = frozenset((apt_pkg.INSTSTATE_REINSTREQ,
+                            apt_pkg.INSTSTATE_HOLD_REINSTREQ))
+        for pkg in self._cache.packages:
+            cand = get_candidate_ver(pkg)
+            if cand and not cand.downloadable and pkg.inst_state in states:
+                reqreinst.add(pkg.get_fullname(pretty=True))
+        return reqreinst
+
+    def _run_fetcher(self, fetcher, allow_unauthenticated):
+        # type: (apt_pkg.Acquire, Optional[bool]) -> int
+        if allow_unauthenticated is None:
+            allow_unauthenticated = apt_pkg.config.find_b("APT::Get::"
+                                        "AllowUnauthenticated", False)
+
+        untrusted = [item for item in fetcher.items if not item.is_trusted]
+        if untrusted and not allow_unauthenticated:
+            raise UntrustedException("Untrusted packages:\n%s" %
+                "\n".join(i.desc_uri for i in untrusted))
+
+        # do the actual fetching
+        res = fetcher.run()
+
+        # now check the result (this is the code from apt-get.cc)
+        failed = False
+        err_msg = ""
+        for item in fetcher.items:
+            if item.status == item.STAT_DONE:
+                continue
+            if item.STAT_IDLE:
+                continue
+            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.RESULT_CANCELLED:
+            raise FetchCancelledException(err_msg)
+        elif failed:
+            raise FetchFailedException(err_msg)
+        return res
+
+    def _fetch_archives(self,
+                        fetcher,                # type: apt_pkg.Acquire
+                        pm,                     # type: apt_pkg.PackageManager
+                        allow_unauthenticated=None,  # type: Optional[bool]
+                        ):
+        # type: (...) -> int
+        """ fetch the needed archives """
+        if self._records is None:
+            raise CacheClosedException(
+                "Cache object used after close() called")
+
+        # this may as well throw a SystemError exception
+        if not pm.get_archives(fetcher, self._list, self._records):
+            return False
+
+        # now run the fetcher, throw exception if something fails to be
+        # fetched
+        return self._run_fetcher(fetcher, allow_unauthenticated)
+
+    def fetch_archives(self,
+                       progress=None,        # type: Optional[AcquireProgress]
+                       fetcher=None,         # type: Optional[apt_pkg.Acquire]
+                       allow_unauthenticated=None,  # type: Optional[bool]
+                       ):
+        # type: (...) -> int
+        """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 occurred,
+        an exception of type :class:`FetchFailedException` or
+        :class:`FetchCancelledException` is raised.
+
+        The keyword-only parameter *allow_unauthenticated* specifies whether
+        to allow unauthenticated downloads. If not specified, it defaults to
+        the configuration option `APT::Get::AllowUnauthenticated`.
+
+        .. 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)
+
+        with self._archive_lock:
+            return self._fetch_archives(fetcher,
+                                        apt_pkg.PackageManager(self._depcache),
+                                        allow_unauthenticated)
+
+    def is_virtual_package(self, pkgname):
+        # type: (str) -> bool
+        """Return whether the package is a virtual package."""
+        try:
+            pkg = self._cache[pkgname]
+        except KeyError:
+            return False
+        else:
+            return bool(pkg.has_provides and not pkg.has_versions)
+
+    def get_providing_packages(self, pkgname, candidate_only=True,
+                               include_nonvirtual=False):
+        # type: (str, bool, bool) -> List[Package]
+        """Return a list of all packages providing a package.
+
+        Return a list of packages which provide the virtual package of the
+        specified name.
+
+        If 'candidate_only' is False, return all packages with at
+        least one version providing the virtual package. Otherwise,
+        return only those packages where the candidate version
+        provides the virtual package.
+
+        If 'include_nonvirtual' is True then it will search for all
+        packages providing pkgname, even if pkgname is not itself
+        a virtual pkg.
+        """
+
+        providers = set()  # type: Set[Package]
+        get_candidate_ver = self._depcache.get_candidate_ver
+        try:
+            vp = self._cache[pkgname]
+            if vp.has_versions and not include_nonvirtual:
+                return list(providers)
+        except KeyError:
+            return list(providers)
+
+        for provides, providesver, version in vp.provides_list:
+            rawpkg = version.parent_pkg
+            if not candidate_only or (version == get_candidate_ver(rawpkg)):
+                providers.add(self._rawpkg_to_pkg(rawpkg))
+        return list(providers)
+
+    def update(self, fetch_progress=None, pulse_interval=0,
+               raise_on_error=True, sources_list=None):
+        # type: (Optional[AcquireProgress], int, bool, Optional[str]) -> int
+        """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()
+        .
+        sources_list -- Update a alternative sources.list than the default.
+        Note that the sources.list.d directory is ignored in this case
+        """
+        with _WrappedLock(apt_pkg.config.find_dir("Dir::State::Lists")):
+            if sources_list:
+                old_sources_list = apt_pkg.config.find("Dir::Etc::sourcelist")
+                old_sources_list_d = (
+                    apt_pkg.config.find("Dir::Etc::sourceparts"))
+                old_cleanup = apt_pkg.config.find("APT::List-Cleanup")
+                apt_pkg.config.set("Dir::Etc::sourcelist",
+                                   os.path.abspath(sources_list))
+                apt_pkg.config.set("Dir::Etc::sourceparts", "xxx")
+                apt_pkg.config.set("APT::List-Cleanup", "0")
+                slist = apt_pkg.SourceList()
+                slist.read_main_list()
+            else:
+                slist = self._list
+
+            try:
+                if fetch_progress is None:
+                    fetch_progress = apt.progress.base.AcquireProgress()
+                try:
+                    res = self._cache.update(fetch_progress, slist,
+                                             pulse_interval)
+                except SystemError as e:
+                    raise FetchFailedException(e)
+                if not res and raise_on_error:
+                    raise FetchFailedException()
+                else:
+                    return res
+            finally:
+                if sources_list:
+                    apt_pkg.config.set("Dir::Etc::sourcelist",
+                                       old_sources_list)
+                    apt_pkg.config.set("Dir::Etc::sourceparts",
+                                       old_sources_list_d)
+                    apt_pkg.config.set("APT::List-Cleanup",
+                                       old_cleanup)
+
+    def install_archives(self, pm, install_progress):
+        # type: (apt_pkg.PackageManager, InstallProgress) -> int
+        """
+        The first parameter *pm* refers to an object returned by
+        apt_pkg.PackageManager().
+
+        The second parameter *install_progress* refers to an InstallProgress()
+        object of the module apt.progress.
+
+        This releases a system lock in newer versions, if there is any,
+        and reestablishes it afterwards.
+        """
+        # compat with older API
+        try:
+            install_progress.startUpdate()  # type: ignore
+        except AttributeError:
+            install_progress.start_update()
+
+        did_unlock = apt_pkg.pkgsystem_is_locked()
+        if did_unlock:
+            apt_pkg.pkgsystem_unlock_inner()
+
+        try:
+            res = install_progress.run(pm)
+        finally:
+            if did_unlock:
+                apt_pkg.pkgsystem_lock_inner()
+
+        try:
+            install_progress.finishUpdate()  # type: ignore
+        except AttributeError:
+            install_progress.finish_update()
+        return res
+
+    def commit(self,
+               fetch_progress=None,         # type: Optional[AcquireProgress]
+               install_progress=None,       # type: Optional[InstallProgress]
+               allow_unauthenticated=None,  # type: Optional[bool]
+               ):
+        # type: (...) -> bool
+        """Apply the marked changes to the cache.
+
+        The first parameter, *fetch_progress*, refers to a FetchProgress()
+        object as found in apt.progress, the default being
+        apt.progress.FetchProgress().
+
+        The second parameter, *install_progress*, is a
+        apt.progress.InstallProgress() object.
+
+        The keyword-only parameter *allow_unauthenticated* specifies whether
+        to allow unauthenticated downloads. If not specified, it defaults to
+        the configuration option `APT::Get::AllowUnauthenticated`.
+        """
+        # FIXME:
+        # use the new acquire/pkgmanager interface here,
+        # raise exceptions when a download or install fails
+        # and send proper error strings to the application.
+        # Current a failed download will just display "error"
+        # which is less than optimal!
+
+        if fetch_progress is None:
+            fetch_progress = apt.progress.base.AcquireProgress()
+        if install_progress is None:
+            install_progress = apt.progress.base.InstallProgress()
+
+        assert install_progress is not None
+
+        with apt_pkg.SystemLock():
+            pm = apt_pkg.PackageManager(self._depcache)
+            fetcher = apt_pkg.Acquire(fetch_progress)
+            with self._archive_lock:
+                while True:
+                    # fetch archives first
+                    res = self._fetch_archives(fetcher, pm,
+                                               allow_unauthenticated)
+
+                    # then install
+                    res = self.install_archives(pm, install_progress)
+                    if res == pm.RESULT_COMPLETED:
+                        break
+                    elif res == pm.RESULT_FAILED:
+                        raise SystemError("installArchives() failed")
+                    elif res == pm.RESULT_INCOMPLETE:
+                        pass
+                    else:
+                        raise SystemError("internal-error: unknown result "
+                                          "code from InstallArchives: %s" %
+                                          res)
+                    # reload the fetcher for media swaping
+                    fetcher.shutdown()
+        return (res == pm.RESULT_COMPLETED)
+
+    def clear(self):
+        # type: () -> None
+        """ Unmark all changes """
+        self._depcache.init()
+
+    # cache changes
+
+    def cache_post_change(self):
+        # type: () -> None
+        " called internally if the cache has changed, emit a signal then "
+        self._run_callbacks("cache_post_change")
+
+    def cache_pre_change(self):
+        # type: () -> None
+        """ called internally if the cache is about to change, emit
+            a signal then """
+        self._run_callbacks("cache_pre_change")
+
+    def connect(self, name, callback):
+        # type: (str, Union[Callable[..., None],str]) -> None
+        """Connect to a signal.
+
+        .. deprecated:: 1.0
+
+            Please use connect2() instead, as this function is very
+            likely to cause a memory leak.
+        """
+        if callback != '_inc_changes_count':
+            warnings.warn("connect() likely causes a reference"
+                          " cycle, use connect2() instead", RuntimeWarning, 2)
+        if name not in self._callbacks:
+            self._callbacks[name] = []
+        self._callbacks[name].append(callback)
+
+    def connect2(self, name, callback, *args, **kwds):
+        # type: (str, Callable[..., Any], object, object) -> None
+        """Connect to a signal.
+
+        The callback will be passed the cache as an argument, and
+        any arguments passed to this function. Make sure that, if you
+        pass a method of a class as your callback, your class does not
+        contain a reference to the cache.
+
+        Cyclic references to the cache can cause issues if the Cache object
+        is replaced by a new one, because the cache keeps a lot of objects and
+        tens of open file descriptors.
+
+        currently only used for cache_{post,pre}_{changed,open}.
+
+        .. versionadded:: 1.0
+        """
+        if name not in self._callbacks2:
+            self._callbacks2[name] = []
+        self._callbacks2[name].append((callback, args, kwds))
+
+    def actiongroup(self):
+        # type: () -> apt_pkg.ActionGroup
+        """Return an `ActionGroup` object for the current cache.
+
+        Action groups can be used to speedup actions. The action group is
+        active as soon as it is created, and disabled when the object is
+        deleted or when release() is called.
+
+        You can use the action group as a context manager, this is the
+        recommended way::
+
+            with cache.actiongroup():
+                for package in my_selected_packages:
+                    package.mark_install()
+
+        This way, the action group is automatically released as soon as the
+        with statement block is left. It also has the benefit of making it
+        clear which parts of the code run with a action group and which
+        don't.
+        """
+        return apt_pkg.ActionGroup(self._depcache)
+
+    @property
+    def dpkg_journal_dirty(self):
+        # type: () -> bool
+        """Return True if the dpkg was interrupted
+
+        All dpkg operations will fail until this is fixed, the action to
+        fix the system if dpkg got interrupted is to run
+        'dpkg --configure -a' as root.
+        """
+        dpkg_status_dir = os.path.dirname(
+            apt_pkg.config.find_file("Dir::State::status"))
+        for f in os.listdir(os.path.join(dpkg_status_dir, "updates")):
+            if fnmatch.fnmatch(f, "[0-9]*"):
+                return True
+        return False
+
+    @property
+    def broken_count(self):
+        # type: () -> int
+        """Return the number of packages with broken dependencies."""
+        return self._depcache.broken_count
+
+    @property
+    def delete_count(self):
+        # type: () -> int
+        """Return the number of packages marked for deletion."""
+        return self._depcache.del_count
+
+    @property
+    def install_count(self):
+        # type: () -> int
+        """Return the number of packages marked for installation."""
+        return self._depcache.inst_count
+
+    @property
+    def keep_count(self):
+        # type: () -> int
+        """Return the number of packages marked as keep."""
+        return self._depcache.keep_count
+
+
+class ProblemResolver(object):
+    """Resolve problems due to dependencies and conflicts.
+
+    The first argument 'cache' is an instance of apt.Cache.
+    """
+
+    def __init__(self, cache):
+        # type: (Cache) -> None
+        self._resolver = apt_pkg.ProblemResolver(cache._depcache)
+        self._cache = cache
+
+    def clear(self, package):
+        # type: (Package) -> None
+        """Reset the package to the default state."""
+        self._resolver.clear(package._pkg)
+
+    def protect(self, package):
+        # type: (Package) -> None
+        """Protect a package so it won't be removed."""
+        self._resolver.protect(package._pkg)
+
+    def remove(self, package):
+        # type: (Package) -> None
+        """Mark a package for removal."""
+        self._resolver.remove(package._pkg)
+
+    def resolve(self):
+        # type: () -> None
+        """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):
+        # type: () -> None
+        """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
+
+
+class Filter(object):
+    """ Filter base class """
+
+    def apply(self, pkg):
+        # type: (Package) -> bool
+        """ Filter function, return True if the package matchs a
+            filter criteria and False otherwise
+        """
+        return True
+
+
+class MarkedChangesFilter(Filter):
+    """ Filter that returns all marked changes """
+
+    def apply(self, pkg):
+        # type: (Package) -> bool
+        if pkg.marked_install or pkg.marked_delete or pkg.marked_upgrade:
+            return True
+        else:
+            return False
+
+
+class InstalledFilter(Filter):
+    """Filter that returns all installed packages.
+
+    .. versionadded:: 1.0.0
+    """
+
+    def apply(self, pkg):
+        # type: (Package) -> bool
+        return pkg.is_installed
+
+
+class _FilteredCacheHelper(object):
+    """Helper class for FilteredCache to break a reference cycle."""
+
+    def __init__(self, cache):
+        # type: (Cache) -> None
+        # Do not keep a reference to the cache, or you have a cycle!
+
+        self._filtered = {}  # type: Dict[str,bool]
+        self._filters = []  # type: List[Filter]
+        cache.connect2("cache_post_change", self.filter_cache_post_change)
+        cache.connect2("cache_post_open", self.filter_cache_post_change)
+
+    def _reapply_filter(self, cache):
+        # type: (Cache) -> None
+        " internal helper to refilter "
+        # Do not keep a reference to the cache, or you have a cycle!
+        self._filtered = {}
+        for pkg in cache:
+            for f in self._filters:
+                if f.apply(pkg):
+                    self._filtered[pkg.name] = True
+                    break
+
+    def set_filter(self, filter):
+        # type: (Filter) -> None
+        """Set the current active filter."""
+        self._filters = []
+        self._filters.append(filter)
+
+    def filter_cache_post_change(self, cache):
+        # type: (Cache) -> None
+        """Called internally if the cache changes, emit a signal then."""
+        # Do not keep a reference to the cache, or you have a cycle!
+        self._reapply_filter(cache)
+
+
+class FilteredCache(object):
+    """ A package cache that is filtered.
+
+        Can work on a existing cache or create a new one
+    """
+
+    def __init__(self, cache=None, progress=None):
+        # type: (Optional[Cache], Optional[OpProgress]) -> None
+        if cache is None:
+            self.cache = Cache(progress)
+        else:
+            self.cache = cache
+        self._helper = _FilteredCacheHelper(self.cache)
+
+    def __len__(self):
+        # type: () -> int
+        return len(self._helper._filtered)
+
+    def __getitem__(self, key):
+        # type: (str) -> Package
+        return self.cache[key]
+
+    def __iter__(self):
+        # type: () -> Iterator[Package]
+        for pkgname in self._helper._filtered:
+            yield self.cache[pkgname]
+
+    def keys(self):
+        # type: () -> KeysView[str]
+        return self._helper._filtered.keys()
+
+    def has_key(self, key):
+        # type: (object) -> bool
+        return key in self
+
+    def __contains__(self, key):
+        # type: (object) -> bool
+        try:
+            # Normalize package name for multi arch
+            return self.cache[key].name in self._helper._filtered
+        except KeyError:
+            return False
+
+    def set_filter(self, filter):
+        # type: (Filter) -> None
+        """Set the current active filter."""
+        self._helper.set_filter(filter)
+        self.cache.cache_post_change()
+
+    def filter_cache_post_change(self):
+        # type: () -> None
+        """Called internally if the cache changes, emit a signal then."""
+        self._helper.filter_cache_post_change(self.cache)
+
+    def __getattr__(self, key):
+        # type: (str) -> Any
+        """we try to look exactly like a real cache."""
+        return getattr(self.cache, key)
+
+
+def cache_pre_changed(cache):
+    # type: (Cache) -> None
+    print("cache pre changed")
+
+
+def cache_post_changed(cache):
+    # type: (Cache) -> None
+    print("cache post changed")
+
+
+def _test():
+    # type: () -> None
+    """Internal test code."""
+    print("Cache self test")
+    apt_pkg.init()
+    cache = Cache(apt.progress.text.OpProgress())
+    cache.connect2("cache_pre_change", cache_pre_changed)
+    cache.connect2("cache_post_change", cache_post_changed)
+    print(("aptitude" in cache))
+    pkg = cache["aptitude"]
+    print(pkg.name)
+    print(len(cache))
+
+    for pkgname in cache.keys():
+        assert cache[pkgname].name == pkgname
+
+    cache.upgrade()
+    changes = cache.get_changes()
+    print(len(changes))
+    for pkg in changes:
+        assert pkg.name
+
+    # see if fetching works
+    for dirname in ["/tmp/pytest", "/tmp/pytest/partial"]:
+        if not os.path.exists(dirname):
+            os.mkdir(dirname)
+    apt_pkg.config.set("Dir::Cache::Archives", "/tmp/pytest")
+    pm = apt_pkg.PackageManager(cache._depcache)
+    fetcher = apt_pkg.Acquire(apt.progress.text.AcquireProgress())
+    cache._fetch_archives(fetcher, pm, None)
+    #sys.exit(1)
+
+    print("Testing filtered cache (argument is old cache)")
+    filtered = FilteredCache(cache)
+    filtered.cache.connect2("cache_pre_change", cache_pre_changed)
+    filtered.cache.connect2("cache_post_change", cache_post_changed)
+    filtered.cache.upgrade()
+    filtered.set_filter(MarkedChangesFilter())
+    print(len(filtered))
+    for pkgname in filtered.keys():
+        assert pkgname == filtered[pkgname].name
+
+    print(len(filtered))
+
+    print("Testing filtered cache (no argument)")
+    filtered = FilteredCache(progress=apt.progress.base.OpProgress())
+    filtered.cache.connect2("cache_pre_change", cache_pre_changed)
+    filtered.cache.connect2("cache_post_change", cache_post_changed)
+    filtered.cache.upgrade()
+    filtered.set_filter(MarkedChangesFilter())
+    print(len(filtered))
+    for pkgname in filtered.keys():
+        assert pkgname == filtered[pkgname].name
+
+    print(len(filtered))
+
+
+if __name__ == '__main__':
+    _test()

apt/cdrom.py

@@ -0,0 +1,92 @@
+# cdrom.py - CDROM handling
+#
+#  Copyright (c) 2005-2009 Canonical
+#  Copyright (c) 2009 Julian Andres Klode <[email protected]>
+#
+#  Author: Michael Vogt <[email protected]>
+#
+#  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 related to cdrom handling."""
+from __future__ import print_function
+
+from typing import Optional
+import glob
+
+import apt_pkg
+from apt.progress.base import CdromProgress
+
+
+class Cdrom(apt_pkg.Cdrom):
+    """Support for apt-cdrom like features.
+
+    This class has several optional parameters for initialisation, which may
+    be used to influence the behaviour of the object:
+
+    The optional parameter `progress` is a CdromProgress() subclass, which will
+    ask for the correct cdrom, etc. If not specified or None, a CdromProgress()
+    object will be used.
+
+    The optional parameter `mountpoint` may be used to specify an alternative
+    mountpoint.
+
+    If the optional parameter `nomount` is True, the cdroms will not be
+    mounted. This is the default behaviour.
+    """
+
+    def __init__(self, progress=None, mountpoint=None, nomount=True):
+        # type: (Optional[CdromProgress], Optional[str], bool) -> None
+        apt_pkg.Cdrom.__init__(self)
+        if progress is None:
+            self._progress = CdromProgress()
+        else:
+            self._progress = progress
+        # see if we have a alternative mountpoint
+        if mountpoint is not None:
+            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")
+        else:
+            apt_pkg.config.set("APT::CDROM::NoMount", "false")
+
+    def add(self, progress=None):
+        # type: (Optional[CdromProgress]) -> bool
+        """Add cdrom to the sources.list."""
+        return apt_pkg.Cdrom.add(self, progress or self._progress)
+
+    def ident(self, progress=None):
+        # type: (Optional[CdromProgress]) -> str
+        """Identify the cdrom."""
+        return apt_pkg.Cdrom.ident(self, progress or self._progress)
+
+    @property
+    def in_sources_list(self):
+        # type: () -> bool
+        """Check if the cdrom is already in the current sources.list."""
+        cd_id = self.ident()
+        if cd_id is None:
+            # FIXME: throw exception instead
+            return False
+        # Get a list of files
+        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:
+            with open(fname) as fobj:
+                for line in fobj:
+                    if not line.lstrip().startswith("#") and cd_id in line:
+                        return True
+        return False

apt/debfile.py

@@ -0,0 +1,868 @@
+#  Copyright (c) 2005-2010 Canonical
+#
+#  Author: Michael Vogt <[email protected]>
+#
+#  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 for working with locally available Debian packages."""
+from __future__ import print_function
+
+import apt
+import apt_inst
+import apt_pkg
+import gzip
+import os
+import sys
+
+from typing import Dict, Iterable, List, Optional, Set, Tuple, Union, cast
+
+from apt_pkg import gettext as _
+from io import BytesIO
+
+
+class NoDebArchiveException(IOError):
+    """Exception which is raised if a file is no Debian archive."""
+
+
+class DebPackage(object):
+    """A Debian Package (.deb file)."""
+
+    # Constants for comparing the local package file with the version
+    # in the cache
+    (VERSION_NONE,
+     VERSION_OUTDATED,
+     VERSION_SAME,
+     VERSION_NEWER) = range(4)
+
+    debug = 0
+
+    def __init__(self, filename=None, cache=None):
+        # type: (Optional[str], Optional[apt.Cache]) -> None
+        if cache is None:
+            cache = apt.Cache()
+        self._cache = cache
+        self._debfile = cast(apt_inst.DebFile, None)
+        self.pkgname = ""
+        self.filename = None  # type: Optional[str]
+        self._sections = {}  # type: Union[Dict[str, str], apt_pkg.TagSection[str]]  # noqa
+        self._need_pkgs = []  # type: List[str]
+        self._check_was_run = False
+        self._failure_string = ""
+        self._multiarch = None  # type: Optional[str]
+        if filename:
+            self.open(filename)
+
+    def open(self, filename):
+        # type: (str) -> None
+        """ open given debfile """
+        self._dbg(3, "open '%s'" % filename)
+        self._need_pkgs = []
+        self._installed_conflicts = set()  # type: Set[str]
+        self._failure_string = ""
+        self.filename = 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"]
+        self._check_was_run = False
+
+    def __getitem__(self, key):
+        # type: (str) -> str
+        return self._sections[key]
+
+    def __contains__(self, key):
+        # type: (str) -> bool
+        return key in self._sections
+
+    @property
+    def filelist(self):
+        # type: () -> List[str]
+        """return the list of files in the deb."""
+        files = []
+        try:
+            self._debfile.data.go(lambda item, data: files.append(item.name))
+        except SystemError:
+            return [_("List of files for '%s' could not be read") %
+                    self.filename]
+        return files
+
+    @property
+    def control_filelist(self):
+        # type: () -> List[str]
+        """ return the list of files in control.tar.gz """
+        control = []
+        try:
+            self._debfile.control.go(
+                lambda item, data: control.append(item.name))
+        except SystemError:
+            return [_("List of control files for '%s' could not be read") %
+                    self.filename]
+        return sorted(control)
+
+    # helper that will return a pkgname with a multiarch suffix if needed
+    def _maybe_append_multiarch_suffix(self, pkgname,
+                                       in_conflict_checking=False):
+        # type: (str, bool) -> str
+        # trivial cases
+        if ":" in pkgname:
+            return pkgname
+        if not self._multiarch:
+            return pkgname
+        elif self._cache.is_virtual_package(pkgname):
+            return pkgname
+        elif (pkgname in self._cache and
+              self._cache[pkgname].candidate is not None and
+              cast(apt.package.Version,
+                   self._cache[pkgname].candidate).architecture == "all"):
+            return pkgname
+        # now do the real multiarch checking
+        multiarch_pkgname = "%s:%s" % (pkgname, self._multiarch)
+        # the upper layers will handle this
+        if multiarch_pkgname not in self._cache:
+            return multiarch_pkgname
+        multiarch_pkg = self._cache[multiarch_pkgname]
+        if multiarch_pkg.candidate is None:
+            return multiarch_pkgname
+        # now check the multiarch state
+        cand = multiarch_pkg.candidate._cand
+        #print pkgname, multiarch_pkgname, cand.multi_arch
+        # the default is to add the suffix, unless its a pkg that can satify
+        # foreign dependencies
+        if cand.multi_arch & cand.MULTI_ARCH_FOREIGN:
+            return pkgname
+        # for conflicts we need a special case here, any not multiarch enabled
+        # package has a implicit conflict
+        if (in_conflict_checking and
+                not (cand.multi_arch & cand.MULTI_ARCH_SAME)):
+            return pkgname
+        return multiarch_pkgname
+
+    def _is_or_group_satisfied(self, or_group):
+        # type: (List[Tuple[str, str, str]]) -> bool
+        """Return True if at least one dependency of the or-group is satisfied.
+
+        This method gets an 'or_group' and analyzes if at least one dependency
+        of this group is already satisfied.
+        """
+        self._dbg(2, "_checkOrGroup(): %s " % (or_group))
+
+        for dep in or_group:
+            depname = dep[0]
+            ver = dep[1]
+            oper = dep[2]
+
+            # multiarch
+            depname = self._maybe_append_multiarch_suffix(depname)
+
+            # check for virtual pkgs
+            if depname not in self._cache:
+                if self._cache.is_virtual_package(depname):
+                    self._dbg(
+                        3, "_is_or_group_satisfied(): %s is virtual dep" %
+                        depname)
+                    for pkg in self._cache.get_providing_packages(depname):
+                        if pkg.is_installed:
+                            return True
+                continue
+            # check real dependency
+            inst = self._cache[depname].installed
+            if inst is not None and apt_pkg.check_dep(inst.version, oper, ver):
+                return True
+
+            # if no real dependency is installed, check if there is
+            # a package installed that provides this dependency
+            # (e.g. scrollkeeper dependecies are provided by rarian-compat)
+            # but only do that if there is no version required in the
+            # dependency (we do not supprot versionized dependencies)
+            if not oper:
+                for ppkg in self._cache.get_providing_packages(
+                    depname, include_nonvirtual=True):
+                    if ppkg.is_installed:
+                        self._dbg(
+                            3, "found installed '%s' that provides '%s'" % (
+                                ppkg.name, depname))
+                        return True
+        return False
+
+    def _satisfy_or_group(self, or_group):
+        # type: (List[Tuple[str, str, str]]) -> bool
+        """Try to satisfy the or_group."""
+        for dep in or_group:
+            depname, ver, oper = dep
+
+            # multiarch
+            depname = self._maybe_append_multiarch_suffix(depname)
+
+            # if we don't have it in the cache, it may be virtual
+            if depname not in self._cache:
+                if not self._cache.is_virtual_package(depname):
+                    continue
+                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:
+                    continue
+                depname = providers[0].name
+
+            # now check if we can satisfy the deps with the candidate(s)
+            # in the cache
+            pkg = self._cache[depname]
+            cand = self._cache._depcache.get_candidate_ver(pkg._pkg)
+            if not cand:
+                continue
+            if not apt_pkg.check_dep(cand.ver_str, oper, ver):
+                continue
+
+            # check if we need to install it
+            self._dbg(2, "Need to get: %s" % depname)
+            self._need_pkgs.append(depname)
+            return True
+
+        # if we reach this point, we failed
+        or_str = ""
+        for dep in or_group:
+            or_str += dep[0]
+            if ver and oper:
+                or_str += " (%s %s)" % (dep[2], dep[1])
+            if dep != or_group[len(or_group) - 1]:
+                or_str += "|"
+        self._failure_string += _(
+            "Dependency is not satisfiable: %s\n") % or_str
+        return False
+
+    def _check_single_pkg_conflict(self, pkgname, ver, oper):
+        # type: (str, str, str) -> bool
+        """Return True if a pkg conflicts with a real installed/marked pkg."""
+        # FIXME: deal with conflicts against its own provides
+        #        (e.g. Provides: ftp-server, Conflicts: ftp-server)
+        self._dbg(
+            3, "_check_single_pkg_conflict() pkg='%s' ver='%s' oper='%s'" % (
+                pkgname, ver, oper))
+        pkg = self._cache[pkgname]
+        if pkg.is_installed:
+            assert pkg.installed is not None
+            pkgver = pkg.installed.version
+        elif pkg.marked_install:
+            assert pkg.candidate is not None
+            pkgver = pkg.candidate.version
+        else:
+            return False
+        #print "pkg: %s" % pkgname
+        #print "ver: %s" % ver
+        #print "pkgver: %s " % pkgver
+        #print "oper: %s " % oper
+        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
+            self._dbg(3, "conflicts with installed pkg '%s'" % pkg.name)
+            return True
+        return False
+
+    def _check_conflicts_or_group(self, or_group):
+        # type: (List[Tuple[str, str, str]]) -> bool
+        """Check the or-group for conflicts with installed pkgs."""
+        self._dbg(2, "_check_conflicts_or_group(): %s " % (or_group))
+        for dep in or_group:
+            depname = dep[0]
+            ver = dep[1]
+            oper = dep[2]
+
+            # FIXME: is this good enough? i.e. will apt always populate
+            #        the cache with conflicting pkgnames for our arch?
+            depname = self._maybe_append_multiarch_suffix(
+                depname, in_conflict_checking=True)
+
+            # check conflicts with virtual pkgs
+            if depname not in self._cache:
+                # FIXME: we have to check for virtual replaces here as
+                #        well (to pass tests/gdebi-test8.deb)
+                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:
+                            self._dbg(3, "conflict on self, ignoring")
+                            continue
+                        if self._check_single_pkg_conflict(
+                                pkg.name, ver, oper):
+                            self._installed_conflicts.add(pkg.name)
+                continue
+            if self._check_single_pkg_conflict(depname, ver, oper):
+                self._installed_conflicts.add(depname)
+        return bool(self._installed_conflicts)
+
+    @property
+    def conflicts(self):
+        # type: () -> List[List[Tuple[str, str, str]]]
+        """List of packages conflicting with this package."""
+        key = "Conflicts"
+        try:
+            return apt_pkg.parse_depends(self._sections[key], False)
+        except KeyError:
+            return []
+
+    @property
+    def depends(self):
+        # type: () -> List[List[Tuple[str, str, str]]]
+        """List of packages on which this package depends on."""
+        depends = []
+        # find depends
+        for key in "Depends", "Pre-Depends":
+            try:
+                depends.extend(
+                    apt_pkg.parse_depends(self._sections[key], False))
+            except KeyError:
+                pass
+        return depends
+
+    @property
+    def provides(self):
+        # type: () -> List[List[Tuple[str, str, str]]]
+        """List of virtual packages which are provided by this package."""
+        key = "Provides"
+        try:
+            return apt_pkg.parse_depends(self._sections[key], False)
+        except KeyError:
+            return []
+
+    @property
+    def replaces(self):
+        # type: () -> List[List[Tuple[str, str, str]]]
+        """List of packages which are replaced by this package."""
+        key = "Replaces"
+        try:
+            return apt_pkg.parse_depends(self._sections[key], False)
+        except KeyError:
+            return []
+
+    def replaces_real_pkg(self, pkgname, oper, ver):
+        # type: (str, str, str) -> bool
+        """Return True if a given non-virtual package is replaced.
+
+        Return True if the deb packages replaces a real (not virtual)
+        packages named (pkgname, oper, ver).
+        """
+        self._dbg(3, "replaces_real_pkg() %s %s %s" % (pkgname, oper, ver))
+        pkg = self._cache[pkgname]
+        pkgver = None  # type: Optional[str]
+        if pkg.is_installed:
+            assert pkg.installed is not None
+            pkgver = pkg.installed.version
+        elif pkg.marked_install:
+            assert pkg.candidate is not None
+            pkgver = pkg.candidate.version
+        else:
+            pkgver = None
+        for or_group in self.replaces:
+            for (name, ver, oper) in or_group:
+                if (name == pkgname and (pkgver is None or
+                        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
+        return False
+
+    def check_conflicts(self):
+        # type: () -> bool
+        """Check if there are conflicts with existing or selected packages.
+
+        Check if the package conflicts with a existing or to be installed
+        package. Return True if the pkg is OK.
+        """
+        res = True
+        for or_group in self.conflicts:
+            if self._check_conflicts_or_group(or_group):
+                #print "Conflicts with a exisiting pkg!"
+                #self._failure_string = "Conflicts with a exisiting pkg!"
+                res = False
+        return res
+
+    def check_breaks_existing_packages(self):
+        # type: () -> bool
+        """
+        check if installing the package would break exsisting
+        package on the system, e.g. system has:
+        smc depends on smc-data (= 1.4)
+        and user tries to installs smc-data 1.6
+        """
+        # show progress information as this step may take some time
+        size = float(len(self._cache))
+        steps = max(int(size / 50), 1)
+        debver = self._sections["Version"]
+        debarch = self._sections["Architecture"]
+        # store what we provide so that we can later check against that
+        provides = [x[0][0] for x in self.provides]
+        for (i, pkg) in enumerate(self._cache):
+            if i % steps == 0:
+                self._cache.op_progress.update(float(i) / size * 100.0)
+            if not pkg.is_installed:
+                continue
+            assert pkg.installed is not None
+            # check if the exising dependencies are still satisfied
+            # with the package
+            ver = pkg._pkg.current_ver
+            for dep_or in pkg.installed.dependencies:
+                for dep in dep_or.or_dependencies:
+                    if dep.name == self.pkgname:
+                        if not apt_pkg.check_dep(
+                                debver, dep.relation, dep.version):
+                            self._dbg(2, "would break (depends) %s" % pkg.name)
+                            # TRANSLATORS: the first '%s' is the package that
+                            # breaks, the second the dependency that makes it
+                            # break, the third the relation (e.g. >=) and the
+                            # latest the version for the releation
+                            self._failure_string += _(
+                                "Breaks existing package '%(pkgname)s' "
+                                "dependency %(depname)s "
+                                "(%(deprelation)s %(depversion)s)") % {
+                                    'pkgname': pkg.name,
+                                    'depname': dep.name,
+                                    'deprelation': dep.relation,
+                                    'depversion': dep.version}
+                            self._cache.op_progress.done()
+                            return False
+            # now check if there are conflicts against this package on
+            # the existing system
+            if "Conflicts" in ver.depends_list:
+                for conflicts_ver_list in ver.depends_list["Conflicts"]:
+                    for c_or in conflicts_ver_list:
+                        if (c_or.target_pkg.name == self.pkgname and
+                                c_or.target_pkg.architecture == debarch):
+                            if apt_pkg.check_dep(
+                                    debver, c_or.comp_type, c_or.target_ver):
+                                self._dbg(
+                                    2, "would break (conflicts) %s" % pkg.name)
+                                # TRANSLATORS: the first '%s' is the package
+                                # that conflicts, the second the packagename
+                                # that it conflicts with (so the name of the
+                                # deb the user tries to install), the third is
+                                # the relation (e.g. >=) and the last is the
+                                # version for the relation
+                                self._failure_string += _(
+                                    "Breaks existing package '%(pkgname)s' "
+                                    "conflict: %(targetpkg)s "
+                                    "(%(comptype)s %(targetver)s)") % {
+                                        'pkgname': pkg.name,
+                                        'targetpkg': c_or.target_pkg.name,
+                                        'comptype': c_or.comp_type,
+                                        'targetver': c_or.target_ver}
+                                self._cache.op_progress.done()
+                                return False
+                        if (c_or.target_pkg.name in provides and
+                                self.pkgname != pkg.name):
+                            self._dbg(
+                                2, "would break (conflicts) %s" % provides)
+                            self._failure_string += _(
+                                "Breaks existing package '%(pkgname)s' "
+                                "that conflict: '%(targetpkg)s'. But the "
+                                "'%(debfile)s' provides it via: "
+                                "'%(provides)s'") % {
+                                    'provides': ",".join(provides),
+                                    'debfile': self.filename,
+                                    'targetpkg': c_or.target_pkg.name,
+                                    'pkgname': pkg.name}
+                            self._cache.op_progress.done()
+                            return False
+        self._cache.op_progress.done()
+        return True
+
+    def compare_to_version_in_cache(self, use_installed=True):
+        # type: (bool) -> int
+        """Compare the package to the version available in the cache.
+
+        Checks if the package is already installed or availabe in the cache
+        and if so in what version, returns one of (VERSION_NONE,
+        VERSION_OUTDATED, VERSION_SAME, VERSION_NEWER).
+        """
+        self._dbg(3, "compare_to_version_in_cache")
+        pkgname = self._sections["Package"]
+        architecture = self._sections["Architecture"]
+
+        # Arch qualify the package name
+        pkgname = ":".join([pkgname, architecture])
+
+        debver = self._sections["Version"]
+        self._dbg(1, "debver: %s" % debver)
+        if pkgname in self._cache:
+            pkg = self._cache[pkgname]
+            if use_installed and pkg.installed is not None:
+                cachever = pkg.installed.version
+            elif not use_installed and pkg.candidate is not None:
+                cachever = pkg.candidate.version
+            else:
+                return self.VERSION_NONE
+            if cachever is not None:
+                cmp = apt_pkg.version_compare(cachever, debver)
+                self._dbg(1, "CompareVersion(debver,instver): %s" % cmp)
+                if cmp == 0:
+                    return self.VERSION_SAME
+                elif cmp < 0:
+                    return self.VERSION_NEWER
+                elif cmp > 0:
+                    return self.VERSION_OUTDATED
+        return self.VERSION_NONE
+
+    def check(self, allow_downgrade=False):
+        # type: (bool) -> bool
+        """Check if the package is installable."""
+        self._dbg(3, "check")
+
+        self._check_was_run = True
+
+        # check arch
+        if "Architecture" not in self._sections:
+            self._dbg(1, "ERROR: no architecture field")
+            self._failure_string = _("No Architecture field in the package")
+            return False
+        arch = self._sections["Architecture"]
+        if arch != "all" and arch != apt_pkg.config.find("APT::Architecture"):
+            if arch in apt_pkg.get_architectures():
+                self._multiarch = arch
+                self.pkgname = "%s:%s" % (self.pkgname, self._multiarch)
+                self._dbg(1, "Found multiarch arch: '%s'" % arch)
+            else:
+                self._dbg(1, "ERROR: Wrong architecture dude!")
+                self._failure_string = _("Wrong architecture '%s' "
+                                         "-- Run dpkg --add-architecture to "
+                                         "add it and update afterwards") % arch
+                return False
+
+        # check version
+        if (not allow_downgrade and
+            self.compare_to_version_in_cache() == self.VERSION_OUTDATED):
+            if self._cache[self.pkgname].installed:
+                # the deb is older than the installed
+                self._failure_string = _(
+                    "A later version is already installed")
+                return False
+
+        # FIXME: this sort of error handling sux
+        self._failure_string = ""
+
+        # check conflicts
+        if not self.check_conflicts():
+            return False
+
+        # check if installing it would break anything on the
+        # current system
+        if not self.check_breaks_existing_packages():
+            return False
+
+        # try to satisfy the dependencies
+        if not self._satisfy_depends(self.depends):
+            return False
+
+        # check for conflicts again (this time with the packages that are
+        # makeed for install)
+        if not self.check_conflicts():
+            return False
+
+        if self._cache._depcache.broken_count > 0:
+            self._failure_string = _("Failed to satisfy all dependencies "
+                                     "(broken cache)")
+            # clean the cache again
+            self._cache.clear()
+            return False
+        return True
+
+    def satisfy_depends_str(self, dependsstr):
+        # type: (str) -> bool
+        """Satisfy the dependencies in the given string."""
+        return self._satisfy_depends(apt_pkg.parse_depends(dependsstr, False))
+
+    def _satisfy_depends(self, depends):
+        # type: (List[List[Tuple[str, str, str]]]) -> bool
+        """Satisfy the dependencies."""
+        # turn off MarkAndSweep via a action group (if available)
+        try:
+            _actiongroup = apt_pkg.ActionGroup(self._cache._depcache)
+            _actiongroup  # pyflakes
+        except AttributeError:
+            pass
+        # check depends
+        for or_group in depends:
+            if not self._is_or_group_satisfied(or_group):
+                if not self._satisfy_or_group(or_group):
+                    return False
+        # now try it out in the cache
+        for pkg in self._need_pkgs:
+            try:
+                self._cache[pkg].mark_install(from_user=False)
+            except SystemError:
+                self._failure_string = _("Cannot install '%s'") % pkg
+                self._cache.clear()
+                return False
+        return True
+
+    @property
+    def missing_deps(self):
+        # type: () -> List[str]
+        """Return missing dependencies."""
+        self._dbg(1, "Installing: %s" % self._need_pkgs)
+        if not self._check_was_run:
+            raise AttributeError(
+                "property only available after check() was run")
+        return self._need_pkgs
+
+    @property
+    def required_changes(self):
+        # type: () -> Tuple[List[str], List[str], List[str]]
+        """Get the changes required to satisfy the dependencies.
+
+        Returns: a tuple with (install, remove, unauthenticated)
+        """
+        install = []
+        remove = []
+        unauthenticated = []
+        if not self._check_was_run:
+            raise AttributeError(
+                "property only available after check() was run")
+        for pkg in self._cache:
+            if pkg.marked_install or pkg.marked_upgrade:
+                assert pkg.candidate is not None
+                install.append(pkg.name)
+                # check authentication, one authenticated origin is enough
+                # libapt will skip non-authenticated origins then
+                authenticated = False
+                for origin in pkg.candidate.origins:
+                    authenticated |= origin.trusted
+                if not authenticated:
+                    unauthenticated.append(pkg.name)
+            if pkg.marked_delete:
+                remove.append(pkg.name)
+        return (install, remove, unauthenticated)
+
+    @staticmethod
+    def to_hex(in_data):
+        # type: (str) -> str
+        hex = ""
+        for (i, c) in enumerate(in_data):
+            if i % 80 == 0:
+                hex += "\n"
+            hex += "%2.2x " % ord(c)
+        return hex
+
+    @staticmethod
+    def to_strish(in_data):
+        # type: (Union[str, Iterable[int]]) -> str
+        s = ""
+        # py2 compat, in_data is type string
+        if isinstance(in_data, str):
+            for c in in_data:
+                if ord(c) < 10 or ord(c) > 127:
+                    s += " "
+                else:
+                    s += c
+        # py3 compat, in_data is type bytes
+        else:
+            for b in in_data:
+                if b < 10 or b > 127:
+                    s += " "
+                else:
+                    s += chr(b)
+        return s
+
+    def _get_content(self, part, name, auto_decompress=True, auto_hex=True):
+        # type: (apt_inst.TarFile, str, bool, bool) -> str
+        if name.startswith("./"):
+            name = name[2:]
+        data = part.extractdata(name)
+        # check for zip content
+        if name.endswith(".gz") and auto_decompress:
+            io = BytesIO(data)
+            gz = gzip.GzipFile(fileobj=io)
+            data = _("Automatically decompressed:\n\n").encode("utf-8")
+            data += gz.read()
+        # auto-convert to hex
+        try:
+            return data.decode("utf-8")
+        except Exception:
+            new_data = _("Automatically converted to printable ascii:\n")
+            new_data += self.to_strish(data)
+            return new_data
+
+    def control_content(self, name):
+        # type: (str) -> str
+        """ return the content of a specific control.tar.gz file """
+        try:
+            return self._get_content(self._debfile.control, name)
+        except LookupError:
+            return ""
+
+    def data_content(self, name):
+        # type: (str) -> str
+        """ return the content of a specific control.tar.gz file """
+        try:
+            return self._get_content(self._debfile.data, name)
+        except LookupError:
+            return ""
+
+    def _dbg(self, level, msg):
+        # type: (int, str) -> None
+        """Write debugging output to sys.stderr."""
+        if level <= self.debug:
+            print(msg, file=sys.stderr)
+
+    def install(self, install_progress=None):
+        # type: (Optional[apt.progress.base.InstallProgress]) -> int
+        """Install the package."""
+        if self.filename is None:
+            raise apt_pkg.Error("No filename specified")
+        if install_progress is None:
+            return os.spawnlp(os.P_WAIT, "dpkg", "dpkg", "-i", self.filename)
+        else:
+            try:
+                install_progress.start_update()
+            except AttributeError:
+                install_progress.startUpdate()  # type: ignore
+            res = install_progress.run(self.filename)
+            try:
+                install_progress.finish_update()
+            except AttributeError:
+                install_progress.finishUpdate()  # type: ignore
+            return res
+
+
+class DscSrcPackage(DebPackage):
+    """A locally available source package."""
+
+    def __init__(self, filename=None, cache=None):
+        # type: (Optional[str], Optional[apt.Cache]) -> None
+        DebPackage.__init__(self, None, cache)
+        self.filename = filename  # type: Optional[str]
+        self._depends = []  # type: List[List[Tuple[str, str, str]]]
+        self._conflicts = []  # type: List[List[Tuple[str, str, str]]]
+        self._installed_conflicts = set()  # type: Set[str]
+        self.pkgname = ""
+        self.binaries = []  # type: List[str]
+        self._sections = {}  # type: Dict[str, str]
+        if self.filename is not None:
+            self.open(self.filename)
+
+    @property
+    def depends(self):
+        # type: () -> List[List[Tuple[str, str, str]]]
+        """Return the dependencies of the package"""
+        return self._depends
+
+    @property
+    def conflicts(self):
+        # type: () -> List[List[Tuple[str, str, str]]]
+        """Return the dependencies of the package"""
+        return self._conflicts
+
+    @property
+    def filelist(self):
+        # type: () -> List[str]
+        """Return the list of files associated with this dsc file"""
+        # Files stanza looks like (hash, size, filename, ...)
+        return self._sections['Files'].split()[2::3]
+
+    def open(self, file):
+        # type: (str) -> None
+        """Open the package."""
+        depends_tags = ["Build-Depends", "Build-Depends-Indep"]
+        conflicts_tags = ["Build-Conflicts", "Build-Conflicts-Indep"]
+        fd = apt_pkg.open_maybe_clear_signed_file(file)
+        fobj = os.fdopen(fd)
+        tagfile = apt_pkg.TagFile(fobj)
+        try:
+            for sec in tagfile:
+                for tag in depends_tags:
+                    if tag not in sec:
+                        continue
+                    self._depends.extend(apt_pkg.parse_src_depends(sec[tag]))
+                for tag in conflicts_tags:
+                    if tag not in sec:
+                        continue
+                    self._conflicts.extend(apt_pkg.parse_src_depends(sec[tag]))
+                if 'Source' in sec:
+                    self.pkgname = sec['Source']
+                if 'Binary' in sec:
+                    self.binaries = [b.strip() for b in
+                                     sec['Binary'].split(',')]
+                for tag in sec.keys():
+                    if tag in sec:
+                        self._sections[tag] = sec[tag]
+        finally:
+            del tagfile
+            fobj.close()
+
+        s = _("Install Build-Dependencies for "
+              "source package '%s' that builds %s\n") % (self.pkgname,
+              " ".join(self.binaries))
+        self._sections["Description"] = s
+        self._check_was_run = False
+
+    def check(self, allow_downgrade=False):
+        # type: (bool) -> bool
+        """Check if the package is installable.
+
+        The second parameter is ignored and only exists for compatibility
+        with parent type."""
+        if not self.check_conflicts():
+            for pkgname in self._installed_conflicts:
+                if self._cache[pkgname]._pkg.essential:
+                    raise Exception(_("An essential package would be removed"))
+                self._cache[pkgname].mark_delete()
+        # properties are ok now
+        self._check_was_run = True
+        # FIXME: a additional run of the check_conflicts()
+        #        after _satisfy_depends() should probably be done
+        return self._satisfy_depends(self.depends)
+
+
+def _test():
+    # type: () -> None
+    """Test function"""
+    from apt.cache import Cache
+    from apt.progress.base import InstallProgress
+
+    cache = Cache()
+
+    vp = "www-browser"
+    print("%s virtual: %s" % (vp, cache.is_virtual_package(vp)))
+    providers = cache.get_providing_packages(vp)
+    print("Providers for %s :" % vp)
+    for pkg in providers:
+        print(" %s" % pkg.name)
+
+    d = DebPackage(sys.argv[1], cache)
+    print("Deb: %s" % d.pkgname)
+    if not d.check():
+        print("can't be satified")
+        print(d._failure_string)
+    print("missing deps: %s" % d.missing_deps)
+    print(d.required_changes)
+
+    print(d.filelist)
+
+    print("Installing ...")
+    ret = d.install(InstallProgress())
+    print(ret)
+
+    #s = DscSrcPackage(cache, "../tests/3ddesktop_0.2.9-6.dsc")
+    #s.check_dep()
+    #print "Missing deps: ",s.missingDeps
+    #print "Print required changes: ", s.requiredChanges
+
+    s = DscSrcPackage(cache=cache)
+    ds = "libc6 (>= 2.3.2), libaio (>= 0.3.96) | libaio1 (>= 0.3.96)"
+    print(s._satisfy_depends(apt_pkg.parse_depends(ds, False)))
+
+
+if __name__ == "__main__":
+    _test()

apt/package.py

@@ -0,0 +1,1604 @@
+# package.py - apt package abstraction
+#
+#  Copyright (c) 2005-2009 Canonical
+#
+#  Author: Michael Vogt <[email protected]>
+#
+#  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
+"""Functionality related to packages."""
+from __future__ import print_function
+
+import logging
+import os
+import sys
+import re
+import socket
+import subprocess
+import threading
+
+from http.client import BadStatusLine
+from urllib.error import HTTPError
+from urllib.request import urlopen
+
+from typing import (Any, Iterable, Iterator, List, Optional, Set,
+                    Tuple, Union, no_type_check, Mapping,
+                    Sequence)
+
+import apt_pkg
+import apt.progress.text
+
+from apt.progress.base import (
+    AcquireProgress,
+    InstallProgress,
+)
+
+from apt_pkg import gettext as _
+
+__all__ = ('BaseDependency', 'Dependency', 'Origin', 'Package', 'Record',
+           'Version', 'VersionList')
+
+
+def _file_is_same(path, size, hashes):
+    # type: (str, int, apt_pkg.HashStringList) -> bool
+    """Return ``True`` if the file is the same."""
+    if os.path.exists(path) and os.path.getsize(path) == size:
+        with open(path) as fobj:
+            return apt_pkg.Hashes(fobj).hashes == hashes
+    return False
+
+
+class FetchError(Exception):
+    """Raised when a file could not be fetched."""
+
+
+class UntrustedError(FetchError):
+    """Raised when a file did not have a trusted hash."""
+
+
+class BaseDependency(object):
+    """A single dependency."""
+
+    class __dstr(str):
+        """Compare helper for compatibility with old third-party code.
+
+        Old third-party code might still compare the relation with the
+        previously used relations (<<,<=,==,!=,>=,>>,) instead of the curently
+        used ones (<,<=,=,!=,>=,>,). This compare helper lets < match to <<,
+        > match to >> and = match to ==.
+        """
+
+        def __eq__(self, other):
+            # type: (object) -> bool
+            if str.__eq__(self, other):
+                return True
+            elif str.__eq__(self, '<'):
+                return str.__eq__('<<', other)
+            elif str.__eq__(self, '>'):
+                return str.__eq__('>>', other)
+            elif str.__eq__(self, '='):
+                return str.__eq__('==', other)
+            else:
+                return False
+
+        def __ne__(self, other):
+            # type: (object) -> bool
+            return not self.__eq__(other)
+
+    def __init__(self, version, dep):
+        # type: (Version, apt_pkg.Dependency) -> None
+        self._version = version  # apt.package.Version
+        self._dep = dep  # apt_pkg.Dependency
+
+    def __str__(self):
+        # type: () -> str
+        return '%s: %s' % (self.rawtype, self.rawstr)
+
+    def __repr__(self):
+        # type: () -> str
+        return ('<BaseDependency: name:%r relation:%r version:%r rawtype:%r>'
+                % (self.name, self.relation, self.version, self.rawtype))
+
+    @property
+    def name(self):
+        # type: () -> str
+        """The name of the target package."""
+        return self._dep.target_pkg.name
+
+    @property
+    def relation(self):
+        # type: () -> str
+        """The relation (<, <=, =, !=, >=, >, '') in mathematical notation.
+
+        The empty string will be returned in case of an unversioned dependency.
+        """
+        return self.__dstr(self._dep.comp_type)
+
+    @property
+    def relation_deb(self):
+        # type: () -> str
+        """The relation (<<, <=, =, !=, >=, >>, '') in Debian notation.
+
+        The empty string will be returned in case of an unversioned dependency.
+        For more details see the Debian Policy Manual on the syntax of
+        relationship fields:
+        https://www.debian.org/doc/debian-policy/ch-relationships.html#s-depsyntax  # noqa
+
+        .. versionadded:: 1.0.0
+        """
+        return self._dep.comp_type_deb
+
+    @property
+    def version(self):
+        # type: () -> str
+        """The target version or an empty string.
+
+        Note that the version is only an empty string in case of an unversioned
+        dependency. In this case the relation is also an empty string.
+        """
+        return self._dep.target_ver
+
+    @property
+    def target_versions(self):
+        # type: () -> List[Version]
+        """A list of all Version objects which satisfy this dependency.
+
+        .. versionadded:: 1.0.0
+        """
+        tvers = []
+        _tvers = self._dep.all_targets()  # type: List[apt_pkg.Version]
+        for _tver in _tvers:  # type: apt_pkg.Version
+            _pkg = _tver.parent_pkg  # type: apt_pkg.Package
+            cache = self._version.package._pcache  # apt.cache.Cache
+            pkg = cache._rawpkg_to_pkg(_pkg)  # apt.package.Package
+            tver = Version(pkg, _tver)  # apt.package.Version
+            tvers.append(tver)
+        return tvers
+
+    @property
+    def installed_target_versions(self):
+        # type: () -> List[Version]
+        """A list of all installed Version objects which satisfy this dep.
+
+        .. versionadded:: 1.0.0
+        """
+        return [tver for tver in self.target_versions if tver.is_installed]
+
+    @property
+    def rawstr(self):
+        # type: () -> str
+        """String represenation of the dependency.
+
+        Returns the string representation of the dependency as it would be
+        written in the debian/control file.  The string representation does not
+        include the type of the dependency.
+
+        Example for an unversioned dependency:
+          python3
+
+        Example for a versioned dependency:
+          python3 >= 3.2
+
+        .. versionadded:: 1.0.0
+        """
+        if self.version:
+            return '%s %s %s' % (self.name, self.relation_deb, self.version)
+        else:
+            return self.name
+
+    @property
+    def rawtype(self):
+        # type: () -> str
+        """Type of the dependency.
+
+        This should be one of 'Breaks', 'Conflicts', 'Depends', 'Enhances',
+        'PreDepends', 'Recommends', 'Replaces', 'Suggests'.
+
+        Additional types might be added in the future.
+        """
+        return self._dep.dep_type_untranslated
+
+    @property
+    def pre_depend(self):
+        # type: () -> bool
+        """Whether this is a PreDepends."""
+        return self._dep.dep_type_untranslated == 'PreDepends'
+
+
+class Dependency(List[BaseDependency]):
+    """Represent an Or-group of dependencies.
+
+    Attributes defined here:
+        or_dependencies - The possible choices
+        rawstr - String represenation of the Or-group of dependencies
+        rawtype - The type of the dependencies in the Or-group
+        target_version - A list of Versions which satisfy this Or-group of deps
+    """
+
+    def __init__(self, version, base_deps, rawtype):
+        # type: (Version, List[BaseDependency], str) -> None
+        super(Dependency, self).__init__(base_deps)
+        self._version = version  # apt.package.Version
+        self._rawtype = rawtype
+
+    def __str__(self):
+        # type: () -> str
+        return '%s: %s' % (self.rawtype, self.rawstr)
+
+    def __repr__(self):
+        # type: () -> str
+        return '<Dependency: [%s]>' % (', '.join(repr(bd) for bd in self))
+
+    @property
+    def or_dependencies(self):
+        # type: () -> Dependency
+        return self
+
+    @property
+    def rawstr(self):
+        # type: () -> str
+        """String represenation of the Or-group of dependencies.
+
+        Returns the string representation of the Or-group of dependencies as it
+        would be written in the debian/control file.  The string representation
+        does not include the type of the Or-group of dependencies.
+
+        Example:
+          python2 >= 2.7 | python3
+
+        .. versionadded:: 1.0.0
+        """
+        return ' | '.join(bd.rawstr for bd in self)
+
+    @property
+    def rawtype(self):
+        # type: () -> str
+        """Type of the Or-group of dependency.
+
+        This should be one of 'Breaks', 'Conflicts', 'Depends', 'Enhances',
+        'PreDepends', 'Recommends', 'Replaces', 'Suggests'.
+
+        Additional types might be added in the future.
+
+        .. versionadded:: 1.0.0
+        """
+        return self._rawtype
+
+    @property
+    def target_versions(self):
+        # type: () -> List[Version]
+        """A list of all Version objects which satisfy this Or-group of deps.
+
+        .. versionadded:: 1.0.0
+        """
+        tvers = []  # type: List[Version]
+        for bd in self:  # apt.package.Dependency
+            for tver in bd.target_versions:  # apt.package.Version
+                if tver not in tvers:
+                    tvers.append(tver)
+        return tvers
+
+    @property
+    def installed_target_versions(self):
+        # type: () -> List[Version]
+        """A list of all installed Version objects which satisfy this dep.
+
+        .. versionadded:: 1.0.0
+        """
+        return [tver for tver in self.target_versions if tver.is_installed]
+
+
+class Origin(object):
+    """The origin of a version.
+
+    Attributes defined here:
+        archive   - The archive (eg. unstable)
+        component - The component (eg. main)
+        label     - The Label, as set in the Release file
+        origin    - The Origin, as set in the Release file
+        codename  - The Codename, as set in the Release file
+        site      - The hostname of the site.
+        trusted   - Boolean value whether this is trustworthy.
+    """
+
+    def __init__(self, pkg, packagefile):
+        # type: (Package, apt_pkg.PackageFile) -> None
+        self.archive = packagefile.archive
+        self.component = packagefile.component
+        self.label = packagefile.label
+        self.origin = packagefile.origin
+        self.codename = packagefile.codename
+        self.site = packagefile.site
+        self.not_automatic = packagefile.not_automatic
+        # check the trust
+        indexfile = pkg._pcache._list.find_index(packagefile)
+        if indexfile and indexfile.is_trusted:
+            self.trusted = True
+        else:
+            self.trusted = False
+
+    def __repr__(self):
+        # type: () -> str
+        return ("<Origin component:%r archive:%r origin:%r label:%r "
+                "site:%r isTrusted:%r>") % (self.component, self.archive,
+                                            self.origin, self.label,
+                                            self.site, self.trusted)
+
+
+class Record(Mapping[Any, Any]):
+    """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.
+
+    """
+
+    def __init__(self, record_str):
+        # type: (str) -> None
+        self._rec = apt_pkg.TagSection(record_str)
+
+    def __hash__(self):
+        # type: () -> int
+        return hash(self._rec)
+
+    def __str__(self):
+        # type: () -> str
+        return str(self._rec)
+
+    def __getitem__(self, key):
+        # type: (str) -> str
+        return self._rec[key]
+
+    def __contains__(self, key):
+        # type: (object) -> bool
+        return key in self._rec
+
+    def __iter__(self):
+        # type: () -> Iterator[str]
+        return iter(self._rec.keys())
+
+    def iteritems(self):
+        # type: () -> Iterable[Tuple[object, str]]
+        """An iterator over the (key, value) items of the record."""
+        for key in self._rec.keys():
+            yield key, self._rec[key]
+
+    def get(self, key, default=None):
+        # type: (str, object) -> object
+        """Return record[key] if key in record, else *default*.
+
+        The parameter *default* must be either a string or None.
+        """
+        return self._rec.get(key, default)
+
+    def has_key(self, key):
+        # type: (str) -> bool
+        """deprecated form of ``key in x``."""
+        return key in self._rec
+
+    def __len__(self):
+        # type: () -> int
+        return len(self._rec)
+
+
+class Version(object):
+    """Representation of a package version.
+
+    The Version class contains all information related to a
+    specific package version.
+
+    .. versionadded:: 0.7.9
+    """
+
+    def __init__(self, package, cand):
+        # type: (Package, apt_pkg.Version) -> None
+        self.package = package
+        self._cand = cand
+        self.package._pcache._weakversions.add(self)
+
+    def _cmp(self, other):
+        # type: (Any) -> Union[int, Any]
+        """Compares against another apt.Version object or a version string.
+
+        This method behaves like Python 2's cmp builtin and returns an integer
+        according to the outcome.  The return value is negative in case of
+        self < other, zero if self == other and positive if self > other.
+
+        The comparison includes the package name and architecture if other is
+        an apt.Version object.  If other isn't an apt.Version object it'll be
+        assumed that other is a version string (without package name/arch).
+
+        .. versionchanged:: 1.0.0
+        """
+        # Assume that other is an apt.Version object.
+        try:
+            self_name = self.package.fullname
+            other_name = other.package.fullname
+            if self_name < other_name:
+                return -1
+            elif self_name > other_name:
+                return 1
+            return apt_pkg.version_compare(self._cand.ver_str, other.version)
+        except AttributeError:
+            # Assume that other is a string that only contains the version.
+            try:
+                return apt_pkg.version_compare(self._cand.ver_str, other)
+            except TypeError:
+                return NotImplemented
+
+    def __eq__(self, other):
+        # type: (object) -> bool
+        return self._cmp(other) == 0
+
+    def __ge__(self, other):
+        # type: (Version) -> bool
+        return self._cmp(other) >= 0
+
+    def __gt__(self, other):
+        # type: (Version) -> bool
+        return self._cmp(other) > 0
+
+    def __le__(self, other):
+        # type: (Version) -> bool
+        return self._cmp(other) <= 0
+
+    def __lt__(self, other):
+        # type: (Version) -> bool
+        return self._cmp(other) < 0
+
+    def __ne__(self, other):
+        # type: (object) -> Union[bool, Any]
+        try:
+            return self._cmp(other) != 0
+        except TypeError:
+            return NotImplemented
+
+    def __hash__(self):
+        # type: () -> int
+        return self._cand.hash
+
+    def __str__(self):
+        # type: () -> str
+        return '%s=%s' % (self.package.name, self.version)
+
+    def __repr__(self):
+        # type: () -> str
+        return '<Version: package:%r version:%r>' % (self.package.name,
+                                                     self.version)
+
+    @property
+    def _records(self):
+        # type: () -> apt_pkg.PackageRecords
+        """Internal helper that moves the Records to the right position."""
+        # If changing lookup, change fetch_binary() as well
+        if not self.package._pcache._records.lookup(self._cand.file_list[0]):
+            raise LookupError("Could not lookup record")
+
+        return self.package._pcache._records
+
+    @property
+    def _translated_records(self):
+        # type: () -> Optional[apt_pkg.PackageRecords]
+        """Internal helper to get the translated description."""
+        desc_iter = self._cand.translated_description
+        if self.package._pcache._records.lookup(desc_iter.file_list.pop(0)):
+            return self.package._pcache._records
+        return None
+
+    @property
+    def installed_size(self):
+        # type: () -> int
+        """Return the size of the package when installed."""
+        return self._cand.installed_size
+
+    @property
+    def homepage(self):
+        # type: () -> str
+        """Return the homepage for the package."""
+        return self._records.homepage
+
+    @property
+    def size(self):
+        # type: () -> int
+        """Return the size of the package."""
+        return self._cand.size
+
+    @property
+    def architecture(self):
+        # type: () -> str
+        """Return the architecture of the package version."""
+        return self._cand.arch
+
+    @property
+    def downloadable(self):
+        # type: () -> bool
+        """Return whether the version of the package is downloadable."""
+        return bool(self._cand.downloadable)
+
+    @property
+    def is_installed(self):
+        # type: () -> bool
+        """Return wether this version of the package is currently installed.
+
+        .. versionadded:: 1.0.0
+        """
+        inst_ver = self.package.installed
+        return (inst_ver is not None and inst_ver._cand.id == self._cand.id)
+
+    @property
+    def version(self):
+        # type: () -> str
+        """Return the version as a string."""
+        return self._cand.ver_str
+
+    @property
+    def summary(self):
+        # type: () -> Optional[str]
+        """Return the short description (one line summary)."""
+        records = self._translated_records
+        return records.short_desc if records is not None else None
+
+    @property
+    def raw_description(self):
+        # type: () -> str
+        """return the long description (raw)."""
+        return self._records.long_desc
+
+    @property
+    def section(self):
+        # type: () -> str
+        """Return the section of the package."""
+        return self._cand.section
+
+    @property
+    def description(self):
+        # type: () -> str
+        """Return the formatted long description.
+
+        Return the formatted long description according to the Debian policy
+        (Chapter 5.6.13).
+        See http://www.debian.org/doc/debian-policy/ch-controlfields.html
+        for more information.
+        """
+        desc = ''
+        records = self._translated_records
+        dsc = records.long_desc if records is not None else None
+
+        if not dsc:
+            return _("Missing description for '%s'."
+                     "Please report.") % (self.package.name)
+
+        try:
+            if not isinstance(dsc, str):
+                # Only convert where needed (i.e. Python 2.X)
+                dsc = dsc.decode("utf-8")
+        except UnicodeDecodeError as err:
+            return _("Invalid unicode in description for '%s' (%s). "
+                     "Please report.") % (self.package.name, err)
+
+        lines = iter(dsc.split("\n"))
+        # Skip the first line, since its a duplication of the summary
+        next(lines)
+        for raw_line in lines:
+            if raw_line.strip() == ".":
+                # The line is just line break
+                if not desc.endswith("\n"):
+                    desc += "\n\n"
+                continue
+            if raw_line.startswith("  "):
+                # The line should be displayed verbatim without word wrapping
+                if not desc.endswith("\n"):
+                    line = "\n%s\n" % raw_line[2:]
+                else:
+                    line = "%s\n" % raw_line[2:]
+            elif raw_line.startswith(" "):
+                # The line is part of a paragraph.
+                if desc.endswith("\n") or desc == "":
+                    # Skip the leading white space
+                    line = raw_line[1:]
+                else:
+                    line = raw_line
+            else:
+                line = raw_line
+            # Add current line to the description
+            desc += line
+        return desc
+
+    @property
+    def source_name(self):
+        # type: () -> str
+        """Return the name of the source package."""
+        try:
+            return self._records.source_pkg or self.package.shortname
+        except IndexError:
+            return self.package.shortname
+
+    @property
+    def source_version(self):
+        # type: () -> str
+        """Return the version of the source package."""
+        try:
+            return self._records.source_ver or self._cand.ver_str
+        except IndexError:
+            return self._cand.ver_str
+
+    @property
+    def priority(self):
+        # type: () -> str
+        """Return the priority of the package, as string."""
+        return self._cand.priority_str
+
+    @property
+    def policy_priority(self):
+        # type: () -> int
+        """Return the internal policy priority as a number.
+           See apt_preferences(5) for more information about what it means.
+        """
+        return self.package._pcache._depcache.policy.get_priority(self._cand)
+
+    @property
+    def record(self):
+        # type: () -> Record
+        """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):
+        # type: (str) -> List[Dependency]
+        """Return a list of Dependency objects for the given types.
+
+        Multiple types can be specified. Possible types are:
+        'Breaks', 'Conflicts', 'Depends', 'Enhances', 'PreDepends',
+        'Recommends', 'Replaces', 'Suggests'
+
+        Additional types might be added in the future.
+        """
+        depends_list = []
+        depends = self._cand.depends_list
+        for type_ in types:
+            try:
+                for dep_ver_list in depends[type_]:
+                    base_deps = []
+                    for dep_or in dep_ver_list:
+                        base_deps.append(BaseDependency(self, dep_or))
+                    depends_list.append(Dependency(self, base_deps, type_))
+            except KeyError:
+                pass
+        return depends_list
+
+    @property
+    def provides(self):
+        # type: () -> List[str]
+        """ Return a list of names that this version provides."""
+        return [p[0] for p in self._cand.provides_list]
+
+    @property
+    def enhances(self):
+        # type: () -> List[Dependency]
+        """Return the list of enhances for the package version."""
+        return self.get_dependencies("Enhances")
+
+    @property
+    def dependencies(self):
+        # type: () -> List[Dependency]
+        """Return the dependencies of the package version."""
+        return self.get_dependencies("PreDepends", "Depends")
+
+    @property
+    def recommends(self):
+        # type: () -> List[Dependency]
+        """Return the recommends of the package version."""
+        return self.get_dependencies("Recommends")
+
+    @property
+    def suggests(self):
+        # type: () -> List[Dependency]
+        """Return the suggests of the package version."""
+        return self.get_dependencies("Suggests")
+
+    @property
+    def origins(self):
+        # type: () -> List[Origin]
+        """Return a list of origins for the package version."""
+        origins = []
+        for (packagefile, _unused) in self._cand.file_list:
+            origins.append(Origin(self.package, packagefile))
+        return origins
+
+    @property
+    def filename(self):
+        # type: () -> str
+        """Return the path to the file inside the archive.
+
+        .. versionadded:: 0.7.10
+        """
+        return self._records.filename
+
+    @property
+    def md5(self):
+        # type: () -> str
+        """Return the md5sum of the binary.
+
+        .. versionadded:: 0.7.10
+        """
+        return self._records.md5_hash
+
+    @property
+    def sha1(self):
+        # type: () -> str
+        """Return the sha1sum of the binary.
+
+        .. versionadded:: 0.7.10
+        """
+        return self._records.sha1_hash
+
+    @property
+    def sha256(self):
+        # type: () -> str
+        """Return the sha256sum of the binary.
+
+        .. versionadded:: 0.7.10
+        """
+        return self._records.sha256_hash
+
+    @property
+    def tasks(self):
+        # type: () -> Set[str]
+        """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):
+        # type: () -> Iterator[str]
+        """Return an iterator over all available urls.
+
+        .. versionadded:: 0.7.10
+        """
+        for (packagefile, _unused) in self._cand.file_list:
+            indexfile = self.package._pcache._list.find_index(packagefile)
+            if indexfile:
+                yield indexfile.archive_uri(self._records.filename)
+
+    @property
+    def uris(self):
+        # type: () -> List[str]
+        """Return a list of all available uris for the binary.
+
+        .. versionadded:: 0.7.10
+        """
+        return list(self._uris())
+
+    @property
+    def uri(self):
+        # type: () -> Optional[str]
+        """Return a single URI for the binary.
+
+        .. versionadded:: 0.7.10
+        """
+        try:
+            return next(iter(self._uris()))
+        except StopIteration:
+            return None
+
+    def fetch_binary(self, destdir='', progress=None,
+                     allow_unauthenticated=None):
+        # type: (str, Optional[AcquireProgress], Optional[bool]) -> str
+        """Fetch the binary version of the package.
+
+        The parameter *destdir* specifies the directory where the package will
+        be fetched to.
+
+        The parameter *progress* may refer to an apt_pkg.AcquireProgress()
+        object. If not specified or None, apt.progress.text.AcquireProgress()
+        is used.
+
+        The keyword-only parameter *allow_unauthenticated* specifies whether
+        to allow unauthenticated downloads. If not specified, it defaults to
+        the configuration option `APT::Get::AllowUnauthenticated`.
+
+        .. versionadded:: 0.7.10
+        """
+        if allow_unauthenticated is None:
+            allow_unauthenticated = apt_pkg.config.find_b("APT::Get::"
+                                        "AllowUnauthenticated", False)
+        base = os.path.basename(self._records.filename)
+        destfile = os.path.join(destdir, base)
+        if _file_is_same(destfile, self.size, self._records.hashes):
+            logging.debug('Ignoring already existing file: %s' % destfile)
+            return os.path.abspath(destfile)
+
+        # Verify that the index is actually trusted
+        pfile, offset = self._cand.file_list[0]
+        index = self.package._pcache._list.find_index(pfile)
+
+        if not (allow_unauthenticated or (index and index.is_trusted)):
+            raise UntrustedError("Could not fetch %s %s source package: "
+                                 "Source %r is not trusted" %
+                                 (self.package.name, self.version,
+                                  getattr(index, "describe", "<unkown>")))
+        if not self.uri:
+            raise ValueError("No URI for this binary.")
+        hashes = self._records.hashes
+        if not (allow_unauthenticated or hashes.usable):
+            raise UntrustedError("The item %r could not be fetched: "
+                                     "No trusted hash found." %
+                                     destfile)
+        acq = apt_pkg.Acquire(progress or apt.progress.text.AcquireProgress())
+        acqfile = apt_pkg.AcquireFile(acq, self.uri, hashes,
+                                      self.size, base, destfile=destfile)
+        acq.run()
+
+        if acqfile.status != acqfile.STAT_DONE:
+            raise FetchError("The item %r could not be fetched: %s" %
+                             (acqfile.destfile, acqfile.error_text))
+
+        return os.path.abspath(destfile)
+
+    def fetch_source(self, destdir="", progress=None, unpack=True,
+                     allow_unauthenticated=None):
+        # type: (str, Optional[AcquireProgress], bool, Optional[bool]) -> str
+        """Get the source code of a package.
+
+        The parameter *destdir* specifies the directory where the source will
+        be fetched to.
+
+        The parameter *progress* may refer to an apt_pkg.AcquireProgress()
+        object. If not specified or None, apt.progress.text.AcquireProgress()
+        is used.
+
+        The parameter *unpack* describes whether the source should be unpacked
+        (``True``) or not (``False``). By default, it is unpacked.
+
+        If *unpack* is ``True``, the path to the extracted directory is
+        returned. Otherwise, the path to the .dsc file is returned.
+
+        The keyword-only parameter *allow_unauthenticated* specifies whether
+        to allow unauthenticated downloads. If not specified, it defaults to
+        the configuration option `APT::Get::AllowUnauthenticated`.
+        """
+        if allow_unauthenticated is None:
+            allow_unauthenticated = apt_pkg.config.find_b("APT::Get::"
+                                        "AllowUnauthenticated", False)
+
+        src = apt_pkg.SourceRecords()
+        acq = apt_pkg.Acquire(progress or apt.progress.text.AcquireProgress())
+
+        dsc = None
+        record = self._records
+        source_name = record.source_pkg or self.package.shortname
+        source_version = record.source_ver or self._cand.ver_str
+        source_lookup = src.lookup(source_name)
+
+        while source_lookup and source_version != src.version:
+            source_lookup = src.lookup(source_name)
+        if not source_lookup:
+            raise ValueError("No source for %r" % self)
+        files = list()
+
+        if not (allow_unauthenticated or src.index.is_trusted):
+            raise UntrustedError("Could not fetch %s %s source package: "
+                                 "Source %r is not trusted" %
+                                 (self.package.name, self.version,
+                                  src.index.describe))
+        for fil in src.files:
+            base = os.path.basename(fil.path)
+            destfile = os.path.join(destdir, base)
+            if fil.type == 'dsc':
+                dsc = destfile
+            if _file_is_same(destfile, fil.size, fil.hashes):
+                logging.debug('Ignoring already existing file: %s' % destfile)
+                continue
+
+            if not (allow_unauthenticated or fil.hashes.usable):
+                raise UntrustedError("The item %r could not be fetched: "
+                                         "No trusted hash found." %
+                                         destfile)
+            files.append(apt_pkg.AcquireFile(acq,
+                            src.index.archive_uri(fil.path),
+                            fil.hashes, fil.size, base, destfile=destfile))
+        acq.run()
+
+        if dsc is None:
+            raise ValueError("No source for %r" % self)
+
+        for item in acq.items:
+            if item.status != item.STAT_DONE:
+                raise FetchError("The item %r could not be fetched: %s" %
+                                 (item.destfile, item.error_text))
+
+        if unpack:
+            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)
+        else:
+            return os.path.abspath(dsc)
+
+
+class VersionList(Sequence[Version]):
+    """Provide a mapping & sequence interface to all versions of a package.
+
+    This class can be used like a dictionary, where version strings are the
+    keys. It can also be used as a sequence, where integers are the keys.
+
+    You can also convert this to a dictionary or a list, using the usual way
+    of dict(version_list) or list(version_list). This is useful if you need
+    to access the version objects multiple times, because they do not have to
+    be recreated this way.
+
+    Examples ('package.versions' being a version list):
+        '0.7.92' in package.versions # Check whether 0.7.92 is a valid version.
+        package.versions[0] # Return first version or raise IndexError
+        package.versions[0:2] # Return a new VersionList for objects 0-2
+        package.versions['0.7.92'] # Return version 0.7.92 or raise KeyError
+        package.versions.keys() # All keys, as strings.
+        max(package.versions)
+    """
+
+    def __init__(self, package, slice_=None):
+        # type: (Package, Optional[slice]) -> None
+        self._package = package  # apt.package.Package()
+        self._versions = package._pkg.version_list  # [apt_pkg.Version(), ...]
+        if slice_:
+            self._versions = self._versions[slice_]
+
+    def __getitem__(self, item):
+        # type: (Union[int, slice, str]) -> Any
+        # FIXME: Should not be returning Any, should have overloads; but
+        # pyflakes complains
+        if isinstance(item, slice):
+            return self.__class__(self._package, item)
+        try:
+            # Sequence interface, item is an integer
+            return Version(self._package, self._versions[item])  # type: ignore
+        except TypeError:
+            # Dictionary interface item is a string.
+            for ver in self._versions:
+                if ver.ver_str == item:
+                    return Version(self._package, ver)
+        raise KeyError("Version: %r not found." % (item))
+
+    def __str__(self):
+        # type: () -> str
+        return '[%s]' % (', '.join(str(ver) for ver in self))
+
+    def __repr__(self):
+        # type: () -> str
+        return '<VersionList: %r>' % self.keys()
+
+    def __iter__(self):
+        # type: () -> Iterator[Version]
+        """Return an iterator over all value objects."""
+        return (Version(self._package, ver) for ver in self._versions)
+
+    def __contains__(self, item):
+        # type: (object) -> bool
+        if isinstance(item, Version):  # Sequence interface
+            item = item.version
+        # Dictionary interface.
+        for ver in self._versions:
+            if ver.ver_str == item:
+                return True
+        return False
+
+    def __eq__(self, other):
+        # type: (Any) -> bool
+        return list(self) == list(other)
+
+    def __len__(self):
+        # type: () -> int
+        return len(self._versions)
+
+    # Mapping interface
+
+    def keys(self):
+        # type: () -> List[str]
+        """Return a list of all versions, as strings."""
+        return [ver.ver_str for ver in self._versions]
+
+    def get(self, key, default=None):
+        # type: (str, Optional[Version]) -> Optional[Version]
+        """Return the key or the default."""
+        try:
+            return self[key]  # type: ignore  # FIXME: should be deterined automatically # noqa
+        except LookupError:
+            return default
+
+
+class Package(object):
+    """Representation of a package in a cache.
+
+    This class provides methods and properties for working with a package. It
+    lets you mark the package for installation, check if it is installed, and
+    much more.
+    """
+
+    def __init__(self, pcache, pkgiter):
+        # type: (apt.Cache, apt_pkg.Package) -> None
+        """ Init the Package object """
+        self._pkg = pkgiter
+        self._pcache = pcache           # python cache in cache.py
+        self._changelog = ""            # Cached changelog
+
+    def __str__(self):
+        # type: () -> str
+        return self.name
+
+    def __repr__(self):
+        # type: () -> str
+        return '<Package: name:%r architecture=%r id:%r>' % (
+            self._pkg.name, self._pkg.architecture, self._pkg.id)
+
+    def __lt__(self, other):
+        # type: (Package) -> bool
+        return self.name < other.name
+
+    @property
+    def candidate(self):
+        # type: () -> Optional[Version]
+        """Return the candidate version of the package.
+
+        This property is writeable to allow you to set the candidate version
+        of the package. Just assign a Version() object, and it will be set as
+        the candidate version.
+        """
+        cand = self._pcache._depcache.get_candidate_ver(self._pkg)
+        if cand is not None:
+            return Version(self, cand)
+        return None
+
+    @candidate.setter
+    def candidate(self, version):
+        # type: (Version) -> None
+        """Set the candidate version of the package."""
+        self._pcache.cache_pre_change()
+        self._pcache._depcache.set_candidate_ver(self._pkg, version._cand)
+        self._pcache.cache_post_change()
+
+    @property
+    def installed(self):
+        # type: () -> Optional[Version]
+        """Return the currently installed version of the package.
+
+        .. versionadded:: 0.7.9
+        """
+        if self._pkg.current_ver is not None:
+            return Version(self, self._pkg.current_ver)
+        return None
+
+    @property
+    def name(self):
+        # type: () -> str
+        """Return the name of the package, possibly including architecture.
+
+        If the package is not part of the system's preferred architecture,
+        return the same as :attr:`fullname`, otherwise return the same
+        as :attr:`shortname`
+
+        .. versionchanged:: 0.7.100.3
+
+        As part of multi-arch, this field now may include architecture
+        information.
+        """
+        return self._pkg.get_fullname(True)
+
+    @property
+    def fullname(self):
+        # type: () -> str
+        """Return the name of the package, including architecture.
+
+        Note that as for :meth:`architecture`, this returns the
+        native architecture for Architecture: all packages.
+
+        .. versionadded:: 0.7.100.3"""
+        return self._pkg.get_fullname(False)
+
+    @property
+    def shortname(self):
+        # type: () -> str
+        """Return the name of the package, without architecture.
+
+        .. versionadded:: 0.7.100.3"""
+        return self._pkg.name
+
+    @property
+    def id(self):
+        # type: () -> int
+        """Return a uniq ID for the package.
+
+        This can be used eg. to store additional information about the pkg."""
+        return self._pkg.id
+
+    @property
+    def essential(self):
+        # type: () -> bool
+        """Return True if the package is an essential part of the system."""
+        return self._pkg.essential
+
+    def architecture(self):
+        # type: () -> str
+        """Return the Architecture of the package.
+
+        Note that for Architecture: all packages, this returns the
+        native architecture, as they are internally treated like native
+        packages. To get the concrete architecture, look at the
+        :attr:`Version.architecture` attribute.
+
+        .. versionchanged:: 0.7.100.3
+            This is now the package's architecture in the multi-arch sense,
+            previously it was the architecture of the candidate version
+            and deprecated.
+        """
+        return self._pkg.architecture
+
+    # depcache states
+
+    @property
+    def marked_install(self):
+        # type: () -> bool
+        """Return ``True`` if the package is marked for install."""
+        return self._pcache._depcache.marked_install(self._pkg)
+
+    @property
+    def marked_upgrade(self):
+        # type: () -> bool
+        """Return ``True`` if the package is marked for upgrade."""
+        return self._pcache._depcache.marked_upgrade(self._pkg)
+
+    @property
+    def marked_delete(self):
+        # type: () -> bool
+        """Return ``True`` if the package is marked for delete."""
+        return self._pcache._depcache.marked_delete(self._pkg)
+
+    @property
+    def marked_keep(self):
+        # type: () -> bool
+        """Return ``True`` if the package is marked for keep."""
+        return self._pcache._depcache.marked_keep(self._pkg)
+
+    @property
+    def marked_downgrade(self):
+        # type: () -> bool
+        """ Package is marked for downgrade """
+        return self._pcache._depcache.marked_downgrade(self._pkg)
+
+    @property
+    def marked_reinstall(self):
+        # type: () -> bool
+        """Return ``True`` if the package is marked for reinstall."""
+        return self._pcache._depcache.marked_reinstall(self._pkg)
+
+    @property
+    def is_installed(self):
+        # type: () -> bool
+        """Return ``True`` if the package is installed."""
+        return (self._pkg.current_ver is not None)
+
+    @property
+    def is_upgradable(self):
+        # type: () -> bool
+        """Return ``True`` if the package is upgradable."""
+        return (self.is_installed and
+                self._pcache._depcache.is_upgradable(self._pkg))
+
+    @property
+    def is_auto_removable(self):
+        # type: () -> bool
+        """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.is_installed or self.marked_install) and
+                self._pcache._depcache.is_garbage(self._pkg))
+
+    @property
+    def is_auto_installed(self):
+        # type: () -> bool
+        """Return whether the package is marked as automatically installed."""
+        return self._pcache._depcache.is_auto_installed(self._pkg)
+    # sizes
+
+    @property
+    def installed_files(self):
+        # type: () -> List[str]
+        """Return a list of files installed by the package.
+
+        Return a list of unicode names of the files which have
+        been installed by this package
+        """
+        for name in self.name, self.fullname:
+            path = "/var/lib/dpkg/info/%s.list" % name
+            try:
+                with open(path, "rb") as file_list:
+                    return file_list.read().decode("utf-8").split(u"\n")
+            except EnvironmentError:
+                continue
+
+        return []
+
+    def get_changelog(self, uri=None, cancel_lock=None):
+        # type: (Optional[str], Optional[threading.Event]) -> str
+        """
+        Download the changelog of the package and return it as unicode
+        string.
+
+        The parameter *uri* refers to the uri of the changelog file. It may
+        contain multiple named variables which will be substitued. These
+        variables are (src_section, prefix, src_pkg, src_ver). An example is
+        the Ubuntu changelog::
+
+            "http://changelogs.ubuntu.com/changelogs/pool" \\
+                "/%(src_section)s/%(prefix)s/%(src_pkg)s" \\
+                "/%(src_pkg)s_%(src_ver)s/changelog"
+
+        The parameter *cancel_lock* refers to an instance of threading.Event,
+        which if set, prevents the download.
+        """
+        # Return a cached changelog if available
+        if self._changelog != u"":
+            return self._changelog
+
+        if not self.candidate:
+            return _("The list of changes is not available")
+
+        if uri is None:
+            if self.candidate.origins[0].origin == "Debian":
+                uri = "http://packages.debian.org/changelogs/pool" \
+                      "/%(src_section)s/%(prefix)s/%(src_pkg)s" \
+                      "/%(src_pkg)s_%(src_ver)s/changelog"
+            elif self.candidate.origins[0].origin == "Ubuntu":
+                uri = "http://changelogs.ubuntu.com/changelogs/pool" \
+                      "/%(src_section)s/%(prefix)s/%(src_pkg)s" \
+                      "/%(src_pkg)s_%(src_ver)s/changelog"
+            else:
+                res = _("The list of changes is not available")
+                if isinstance(res, str):
+                    return res
+                else:
+                    return res.decode("utf-8")
+
+        # get the src package name
+        src_pkg = self.candidate.source_name
+
+        # assume "main" section
+        src_section = "main"
+        # use the section of the candidate as a starting point
+        section = self.candidate.section
+
+        # get the source version
+        src_ver = self.candidate.source_version
+
+        try:
+            # try to get the source version of the pkg, this differs
+            # for some (e.g. libnspr4 on ubuntu)
+            # this feature only works if the correct deb-src are in the
+            # sources.list otherwise we fall back to the binary version number
+            src_records = apt_pkg.SourceRecords()
+        except SystemError:
+            pass
+        else:
+            while src_records.lookup(src_pkg):
+                if not src_records.version:
+                    continue
+                if self.candidate.source_version == src_records.version:
+                    # Direct match, use it and do not do more lookups.
+                    src_ver = src_records.version
+                    section = src_records.section
+                    break
+                if apt_pkg.version_compare(src_records.version, src_ver) > 0:
+                    # The version is higher, it seems to match.
+                    src_ver = src_records.version
+                    section = src_records.section
+
+        section_split = section.split("/", 1)
+        if len(section_split) > 1:
+            src_section = section_split[0]
+        del section_split
+
+        # lib is handled special
+        prefix = src_pkg[0]
+        if src_pkg.startswith("lib"):
+            prefix = "lib" + src_pkg[3]
+
+        # stip epoch
+        src_ver_split = src_ver.split(":", 1)
+        if len(src_ver_split) > 1:
+            src_ver = "".join(src_ver_split[1:])
+        del src_ver_split
+
+        uri = uri % {"src_section": src_section,
+                     "prefix": prefix,
+                     "src_pkg": src_pkg,
+                     "src_ver": src_ver}
+
+        timeout = socket.getdefaulttimeout()
+
+        # FIXME: when python2.4 vanishes from the archive,
+        #        merge this into a single try..finally block (pep 341)
+        try:
+            try:
+                # Set a timeout for the changelog download
+                socket.setdefaulttimeout(2)
+
+                # Check if the download was canceled
+                if cancel_lock and cancel_lock.is_set():
+                    return u""
+                # FIXME: python3.2: Should be closed manually
+                changelog_file = urlopen(uri)
+                # do only get the lines that are new
+                changelog = u""
+                regexp = "^%s \\((.*)\\)(.*)$" % (re.escape(src_pkg))
+                while True:
+                    # Check if the download was canceled
+                    if cancel_lock and cancel_lock.is_set():
+                        return u""
+                    # Read changelog line by line
+                    line_raw = changelog_file.readline()
+                    if not line_raw:
+                        break
+                    # The changelog is encoded in utf-8, but since there isn't
+                    # any http header, urllib2 seems to treat it as ascii
+                    line = line_raw.decode("utf-8")
+
+                    #print line.encode('utf-8')
+                    match = re.match(regexp, line)
+                    if match:
+                        # strip epoch from installed version
+                        # and from changelog too
+                        installed = getattr(self.installed, 'version', None)
+                        if installed and ":" in installed:
+                            installed = installed.split(":", 1)[1]
+                        changelog_ver = match.group(1)
+                        if changelog_ver and ":" in changelog_ver:
+                            changelog_ver = changelog_ver.split(":", 1)[1]
+
+                        if (installed and apt_pkg.version_compare(
+                                changelog_ver, installed) <= 0):
+                            break
+                    # EOF (shouldn't really happen)
+                    changelog += line
+
+                # Print an error if we failed to extract a changelog
+                if len(changelog) == 0:
+                    changelog = _("The list of changes is not available")
+                    if not isinstance(changelog, str):
+                        changelog = changelog.decode("utf-8")
+                self._changelog = changelog
+
+            except HTTPError:
+                if self.candidate.origins[0].origin == "Ubuntu":
+                    res = _("The list of changes is not available yet.\n\n"
+                            "Please use "
+                            "http://launchpad.net/ubuntu/+source/%s/"
+                            "%s/+changelog\n"
+                            "until the changes become available or try again "
+                            "later.") % (src_pkg, src_ver)
+                else:
+                    res = _("The list of changes is not available")
+                if isinstance(res, str):
+                    return res
+                else:
+                    return res.decode("utf-8")
+            except (IOError, BadStatusLine):
+                res = _("Failed to download the list of changes. \nPlease "
+                        "check your Internet connection.")
+                if isinstance(res, str):
+                    return res
+                else:
+                    return res.decode("utf-8")
+        finally:
+            socket.setdefaulttimeout(timeout)
+        return self._changelog
+
+    @property
+    def versions(self):
+        # type: () -> VersionList
+        """Return a VersionList() object for all available versions.
+
+        .. versionadded:: 0.7.9
+        """
+        return VersionList(self)
+
+    @property
+    def is_inst_broken(self):
+        # type: () -> bool
+        """Return True if the to-be-installed package is broken."""
+        return self._pcache._depcache.is_inst_broken(self._pkg)
+
+    @property
+    def is_now_broken(self):
+        # type: () -> bool
+        """Return True if the installed package is broken."""
+        return self._pcache._depcache.is_now_broken(self._pkg)
+
+    @property
+    def has_config_files(self):
+        # type: () -> bool
+        """Checks whether the package is is the config-files state."""
+        return self. _pkg.current_state == apt_pkg.CURSTATE_CONFIG_FILES
+
+    # depcache actions
+
+    def mark_keep(self):
+        # type: () -> None
+        """Mark a package for keep."""
+        self._pcache.cache_pre_change()
+        self._pcache._depcache.mark_keep(self._pkg)
+        self._pcache.cache_post_change()
+
+    def mark_delete(self, auto_fix=True, purge=False):
+        # type: (bool, bool) -> None
+        """Mark a package for deletion.
+
+        If *auto_fix* is ``True``, the resolver will be run, trying to fix
+        broken packages.  This is the default.
+
+        If *purge* is ``True``, remove the configuration files of the package
+        as well.  The default is to keep the configuration.
+        """
+        self._pcache.cache_pre_change()
+        self._pcache._depcache.mark_delete(self._pkg, purge)
+        # try to fix broken stuffsta
+        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.resolve()
+        self._pcache.cache_post_change()
+
+    def mark_install(self, auto_fix=True, auto_inst=True, from_user=True):
+        # type: (bool, bool, bool) -> None
+        """Mark a package for install.
+
+        If *autoFix* is ``True``, the resolver will be run, trying to fix
+        broken packages.  This is the default.
+
+        If *autoInst* is ``True``, the dependencies of the packages will be
+        installed automatically.  This is the default.
+
+        If *fromUser* is ``True``, this package will not be marked as
+        automatically installed. This is the default. Set it to False if you
+        want to be able to automatically remove the package at a later stage
+        when no other package depends on it.
+        """
+        self._pcache.cache_pre_change()
+        self._pcache._depcache.mark_install(self._pkg, auto_inst, from_user)
+        # try to fix broken stuff
+        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)
+        self._pcache.cache_post_change()
+
+    def mark_upgrade(self, from_user=True):
+        # type: (bool) -> None
+        """Mark a package for upgrade."""
+        if self.is_upgradable:
+            auto = self.is_auto_installed
+            self.mark_install(from_user=from_user)
+            self.mark_auto(auto)
+        else:
+            # FIXME: we may want to throw a exception here
+            sys.stderr.write(("MarkUpgrade() called on a non-upgradeable pkg: "
+                              "'%s'\n") % self._pkg.name)
+
+    def mark_auto(self, auto=True):
+        # type: (bool) -> None
+        """Mark a package as automatically installed.
+
+        Call this function to mark a package as automatically installed. If the
+        optional parameter *auto* is set to ``False``, the package will not be
+        marked as automatically installed anymore. The default is ``True``.
+        """
+        self._pcache._depcache.mark_auto(self._pkg, auto)
+
+    def commit(self, fprogress, iprogress):
+        # type: (AcquireProgress, InstallProgress) -> None
+        """Commit the changes.
+
+        The parameter *fprogress* refers to a apt_pkg.AcquireProgress() object,
+        like apt.progress.text.AcquireProgress().
+
+        The parameter *iprogress* refers to an InstallProgress() object, as
+        found in apt.progress.base.
+        """
+        self._pcache._depcache.commit(fprogress, iprogress)
+
+
+@no_type_check
+def _test():
+    """Self-test."""
+    print("Self-test for the Package modul")
+    import random
+    apt_pkg.init()
+    progress = apt.progress.text.OpProgress()
+    cache = apt.Cache(progress)
+    pkg = cache["apt-utils"]
+    print("Name: %s " % pkg.name)
+    print("ID: %s " % pkg.id)
+    print("Priority (Candidate): %s " % pkg.candidate.priority)
+    print("Priority (Installed): %s " % pkg.installed.priority)
+    print("Installed: %s " % pkg.installed.version)
+    print("Candidate: %s " % pkg.candidate.version)
+    print("CandidateDownloadable: %s" % pkg.candidate.downloadable)
+    print("CandidateOrigins: %s" % pkg.candidate.origins)
+    print("SourcePkg: %s " % pkg.candidate.source_name)
+    print("Section: %s " % pkg.section)
+    print("Summary: %s" % pkg.candidate.summary)
+    print("Description (formatted) :\n%s" % pkg.candidate.description)
+    print("Description (unformatted):\n%s" % pkg.candidate.raw_description)
+    print("InstalledSize: %s " % pkg.candidate.installed_size)
+    print("PackageSize: %s " % pkg.candidate.size)
+    print("Dependencies: %s" % pkg.installed.dependencies)
+    print("Recommends: %s" % pkg.installed.recommends)
+    for dep in pkg.candidate.dependencies:
+        print(",".join("%s (%s) (%s) (%s)" % (o.name, o.version, o.relation,
+                       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"].get_changelog())
+    for i in True, False:
+        print("Running install on random upgradable pkgs with AutoFix: ", i)
+        for pkg in cache:
+            if pkg.is_upgradable:
+                if random.randint(0, 1) == 1:
+                    pkg.mark_install(i)
+        print("Broken: %s " % cache._depcache.broken_count)
+        print("InstCount: %s " % cache._depcache.inst_count)
+
+    print()
+    # get a new cache
+    for i in True, False:
+        print("Randomly remove some packages with AutoFix: %s" % i)
+        cache = apt.Cache(progress)
+        for name in cache.keys():
+            if random.randint(0, 1) == 1:
+                try:
+                    cache[name].mark_delete(i)
+                except SystemError:
+                    print("Error trying to remove: %s " % name)
+        print("Broken: %s " % cache._depcache.broken_count)
+        print("DelCount: %s " % cache._depcache.del_count)
+
+
+# self-test
+if __name__ == "__main__":
+    _test()

apt/progress/__init__.py

@@ -0,0 +1,31 @@
+# apt/progress/__init__.py - Initialization file for apt.progress.
+#
+# Copyright (c) 2009 Julian Andres Klode <[email protected]>
+#
+# 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
+"""Progress reporting.
+
+This package provides progress reporting for the python-apt package. The module
+'base' provides classes with no output, and the module 'text' provides classes
+for terminals, etc.
+"""
+
+from __future__ import print_function
+
+from typing import Sequence
+
+
+__all__ = []  # type: Sequence[str]

apt/progress/base.py

@@ -0,0 +1,354 @@
+# apt/progress/base.py - Base classes for progress reporting.
+#
+# Copyright (C) 2009 Julian Andres Klode <[email protected]>
+#
+# 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
+# pylint: disable-msg = R0201
+"""Base classes for progress reporting.
+
+Custom progress classes should inherit from these classes. They can also be
+used as dummy progress classes which simply do nothing.
+"""
+from __future__ import print_function
+
+import errno
+import fcntl
+import io
+import os
+import re
+import select
+import sys
+
+from typing import Optional, Union
+
+import apt_pkg
+
+__all__ = ['AcquireProgress', 'CdromProgress', 'InstallProgress', 'OpProgress']
+
+
+class AcquireProgress(object):
+    """Monitor object for downloads controlled by the Acquire class.
+
+    This is an mostly abstract class. You should subclass it and implement the
+    methods to get something useful.
+    """
+
+    current_bytes = current_cps = fetched_bytes = last_bytes = total_bytes \
+                  = 0.0
+    current_items = elapsed_time = total_items = 0
+
+    def done(self, item):
+        # type: (apt_pkg.AcquireItemDesc) -> None
+        """Invoked when an item is successfully and completely fetched."""
+
+    def fail(self, item):
+        # type: (apt_pkg.AcquireItemDesc) -> None
+        """Invoked when an item could not be fetched."""
+
+    def fetch(self, item):
+        # type: (apt_pkg.AcquireItemDesc) -> None
+        """Invoked when some of the item's data is fetched."""
+
+    def ims_hit(self, item):
+        # type: (apt_pkg.AcquireItemDesc) -> None
+        """Invoked when an item is confirmed to be up-to-date.
+
+        Invoked when an item is confirmed to be up-to-date. For instance,
+        when an HTTP download is informed that the file on the server was
+        not modified.
+        """
+
+    def media_change(self, media, drive):
+        # type: (str, str) -> bool
+        """Prompt the user to change the inserted removable media.
+
+        The parameter 'media' decribes the name of the media type that
+        should be changed, whereas the parameter 'drive' should be the
+        identifying name of the drive whose media should be changed.
+
+        This method should not return until the user has confirmed to the user
+        interface that the media change is complete. It must return True if
+        the user confirms the media change, or False to cancel it.
+        """
+        return False
+
+    def pulse(self, owner):
+        # type: (apt_pkg.Acquire) -> bool
+        """Periodically invoked while the Acquire process is underway.
+
+        This method gets invoked while the Acquire progress given by the
+        parameter 'owner' is underway. It should display information about
+        the current state.
+
+        This function returns a boolean value indicating whether the
+        acquisition should be continued (True) or cancelled (False).
+        """
+        return True
+
+    def start(self):
+        # type: () -> None
+        """Invoked when the Acquire process starts running."""
+        # Reset all our values.
+        self.current_bytes = 0.0
+        self.current_cps = 0.0
+        self.current_items = 0
+        self.elapsed_time = 0
+        self.fetched_bytes = 0.0
+        self.last_bytes = 0.0
+        self.total_bytes = 0.0
+        self.total_items = 0
+
+    def stop(self):
+        # type: () -> None
+        """Invoked when the Acquire process stops running."""
+
+
+class CdromProgress(object):
+    """Base class for reporting the progress of adding a cdrom.
+
+    Can be used with apt_pkg.Cdrom to produce an utility like apt-cdrom. The
+    attribute 'total_steps' defines the total number of steps and can be used
+    in update() to display the current progress.
+    """
+
+    total_steps = 0
+
+    def ask_cdrom_name(self):
+        # type: () -> Optional[str]
+        """Ask for the name of the cdrom.
+
+        If a name has been provided, return it. Otherwise, return None to
+        cancel the operation.
+        """
+
+    def change_cdrom(self):
+        # type: () -> bool
+        """Ask for the CD-ROM to be changed.
+
+        Return True once the cdrom has been changed or False to cancel the
+        operation.
+        """
+
+    def update(self, text, current):
+        # type: (str, int) -> None
+        """Periodically invoked to update the interface.
+
+        The string 'text' defines the text which should be displayed. The
+        integer 'current' defines the number of completed steps.
+        """
+
+
+class InstallProgress(object):
+    """Class to report the progress of installing packages."""
+
+    child_pid, percent, select_timeout, status = 0, 0.0, 0.1, ""
+
+    def __init__(self):
+        # type: () -> None
+        (self.statusfd, self.writefd) = os.pipe()
+        # These will leak fds, but fixing this safely requires API changes.
+        self.write_stream = os.fdopen(self.writefd, "w")  # type: io.TextIOBase
+        self.status_stream = os.fdopen(self.statusfd, "r")  # type: io.TextIOBase # noqa
+        fcntl.fcntl(self.statusfd, fcntl.F_SETFL, os.O_NONBLOCK)
+
+    def start_update(self):
+        # type: () -> None
+        """(Abstract) Start update."""
+
+    def finish_update(self):
+        # type: () -> None
+        """(Abstract) Called when update has finished."""
+
+    def __enter__(self):
+        # type: () -> InstallProgress
+        return self
+
+    def __exit__(self, type, value, traceback):
+        # type: (object, object, object) -> None
+        self.write_stream.close()
+        self.status_stream.close()
+
+    def error(self, pkg, errormsg):
+        # type: (str, str) -> None
+        """(Abstract) Called when a error is detected during the install."""
+
+    def conffile(self, current, new):
+        # type: (str, str) -> None
+        """(Abstract) Called when a conffile question from dpkg is detected."""
+
+    def status_change(self, pkg, percent, status):
+        # type: (str, float, str) -> None
+        """(Abstract) Called when the APT status changed."""
+
+    def dpkg_status_change(self, pkg, status):
+        # type: (str, str) -> None
+        """(Abstract) Called when the dpkg status changed."""
+
+    def processing(self, pkg, stage):
+        # type: (str, str) -> None
+        """(Abstract) Sent just before a processing stage starts.
+
+        The parameter 'stage' is one of "upgrade", "install"
+        (both sent before unpacking), "configure", "trigproc", "remove",
+        "purge". This method is used for dpkg only.
+        """
+
+    def run(self, obj):
+        # type: (Union[apt_pkg.PackageManager, Union[bytes, str]]) -> int
+        """Install using the object 'obj'.
+
+        This functions runs install actions. The parameter 'obj' may either
+        be a PackageManager object in which case its do_install() method is
+        called or the path to a deb file.
+
+        If the object is a PackageManager, the functions returns the result
+        of calling its do_install() method. Otherwise, the function returns
+        the exit status of dpkg. In both cases, 0 means that there were no
+        problems.
+        """
+        pid = self.fork()
+        if pid == 0:
+            try:
+                # PEP-446 implemented in Python 3.4 made all descriptors
+                # CLOEXEC, but we need to be able to pass writefd to dpkg
+                # when we spawn it
+                os.set_inheritable(self.writefd, True)
+            except AttributeError:  # if we don't have os.set_inheritable()
+                pass
+            # pm.do_install might raise a exception,
+            # when this happens, we need to catch
+            # it, otherwise os._exit() is not run
+            # and the execution continues in the
+            # parent code leading to very confusing bugs
+            try:
+                os._exit(obj.do_install(self.write_stream.fileno()))  # type: ignore # noqa
+            except AttributeError:
+                os._exit(os.spawnlp(os.P_WAIT, "dpkg", "dpkg", "--status-fd",
+                                    str(self.write_stream.fileno()), "-i",
+                                    obj))  # type: ignore # noqa
+            except Exception as e:
+                sys.stderr.write("%s\n" % e)
+                os._exit(apt_pkg.PackageManager.RESULT_FAILED)
+
+        self.child_pid = pid
+        res = self.wait_child()
+        return os.WEXITSTATUS(res)
+
+    def fork(self):
+        # type: () -> int
+        """Fork."""
+        return os.fork()
+
+    def update_interface(self):
+        # type: () -> None
+        """Update the interface."""
+        try:
+            line = self.status_stream.readline()
+        except IOError as err:
+            # resource temporarly unavailable is ignored
+            if err.errno != errno.EAGAIN and err.errno != errno.EWOULDBLOCK:
+                print(err.strerror)
+            return
+
+        pkgname = status = status_str = percent = base = ""
+
+        if line.startswith('pm'):
+            try:
+                (status, pkgname, percent, status_str) = line.split(":", 3)
+            except ValueError:
+                # silently ignore lines that can't be parsed
+                return
+        elif line.startswith('status'):
+            try:
+                (base, pkgname, status, status_str) = line.split(":", 3)
+            except ValueError:
+                (base, pkgname, status) = line.split(":", 2)
+        elif line.startswith('processing'):
+            (status, status_str, pkgname) = line.split(":", 2)
+            self.processing(pkgname.strip(), status_str.strip())
+
+        # Always strip the status message
+        pkgname = pkgname.strip()
+        status_str = status_str.strip()
+        status = status.strip()
+
+        if status == 'pmerror' or status == 'error':
+            self.error(pkgname, status_str)
+        elif status == 'conffile-prompt' or status == 'pmconffile':
+            match = re.match("\\s*\'(.*)\'\\s*\'(.*)\'.*", status_str)
+            if match:
+                self.conffile(match.group(1), match.group(2))
+        elif status == "pmstatus":
+            # FIXME: Float comparison
+            if float(percent) != self.percent or status_str != self.status:
+                self.status_change(pkgname, float(percent), status_str.strip())
+                self.percent = float(percent)
+                self.status = status_str.strip()
+        elif base == "status":
+            self.dpkg_status_change(pkgname, status)
+
+    def wait_child(self):
+        # type: () -> int
+        """Wait for child progress to exit.
+
+        This method is responsible for calling update_interface() from time to
+        time. It exits once the child has exited. The return values is the
+        full status returned from os.waitpid() (not only the return code).
+        """
+        (pid, res) = (0, 0)
+        while True:
+            try:
+                select.select([self.status_stream], [], [],
+                              self.select_timeout)
+            except select.error as error:
+                (errno_, _errstr) = error.args
+                if errno_ != errno.EINTR:
+                    raise
+
+            self.update_interface()
+            try:
+                (pid, res) = os.waitpid(self.child_pid, os.WNOHANG)
+                if pid == self.child_pid:
+                    break
+            except OSError as err:
+                if err.errno == errno.ECHILD:
+                    break
+                if err.errno != errno.EINTR:
+                    raise
+
+        return res
+
+
+class OpProgress(object):
+    """Monitor objects for operations.
+
+    Display the progress of operations such as opening the cache."""
+
+    major_change, op, percent, subop = False, "", 0.0, ""
+
+    def update(self, percent=None):
+        # type: (Optional[float]) -> None
+        """Called periodically to update the user interface.
+
+        You may use the optional argument 'percent' to set the attribute
+        'percent' in this call.
+        """
+        if percent is not None:
+            self.percent = percent
+
+    def done(self):
+        # type: () -> None
+        """Called once an operation has been completed."""

apt/progress/text.py

@@ -0,0 +1,293 @@
+# Copyright (c) 2009 Julian Andres Klode <[email protected]>
+#
+# 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
+"""Progress reporting for text interfaces."""
+from __future__ import print_function
+
+import io
+import os
+import signal
+import sys
+
+import types
+from typing import Callable, Optional, Union
+
+
+import apt_pkg
+from apt.progress import base
+
+
+__all__ = ['AcquireProgress', 'CdromProgress', 'OpProgress']
+
+
+def _(msg):
+    # type: (str) -> str
+    """Translate the message, also try apt if translation is missing."""
+    res = apt_pkg.gettext(msg)
+    if res == msg:
+        res = apt_pkg.gettext(msg, "apt")
+    return res
+
+
+class TextProgress(object):
+    """Internal Base class for text progress classes."""
+
+    def __init__(self, outfile=None):
+        # type: (Optional[io.TextIOBase]) -> None
+        self._file = outfile or sys.stdout
+        self._width = 0
+
+    def _write(self, msg, newline=True, maximize=False):
+        # type: (str, bool, bool) -> None
+        """Write the message on the terminal, fill remaining space."""
+        self._file.write("\r")
+        self._file.write(msg)
+
+        # Fill remaining stuff with whitespace
+        if self._width > len(msg):
+            self._file.write((self._width - len(msg)) * ' ')
+        elif maximize:  # Needed for OpProgress.
+            self._width = max(self._width, len(msg))
+        if newline:
+            self._file.write("\n")
+        else:
+            #self._file.write("\r")
+            self._file.flush()
+
+
+class OpProgress(base.OpProgress, TextProgress):
+    """Operation progress reporting.
+
+    This closely resembles OpTextProgress in libapt-pkg.
+    """
+
+    def __init__(self, outfile=None):
+        # type: (Optional[io.TextIOBase]) -> None
+        TextProgress.__init__(self, outfile)
+        base.OpProgress.__init__(self)
+        self.old_op = ""
+
+    def update(self, percent=None):
+        # type: (Optional[float]) -> None
+        """Called periodically to update the user interface."""
+        base.OpProgress.update(self, percent)
+        if self.major_change and self.old_op:
+            self._write(self.old_op)
+        self._write("%s... %i%%\r" % (self.op, self.percent), False, True)
+        self.old_op = self.op
+
+    def done(self):
+        # type: () -> None
+        """Called once an operation has been completed."""
+        base.OpProgress.done(self)
+        if self.old_op:
+            self._write(_("%c%s... Done") % ('\r', self.old_op), True, True)
+        self.old_op = ""
+
+
+class AcquireProgress(base.AcquireProgress, TextProgress):
+    """AcquireProgress for the text interface."""
+
+    def __init__(self, outfile=None):
+        # type: (Optional[io.TextIOBase]) -> None
+        TextProgress.__init__(self, outfile)
+        base.AcquireProgress.__init__(self)
+        self._signal = None  # type: Union[Callable[[int, Optional[types.FrameType]], None], int, signal.Handlers, None] # noqa
+        self._width = 80
+        self._id = 1
+
+    def start(self):
+        # type: () -> None
+        """Start an Acquire progress.
+
+        In this case, the function sets up a signal handler for SIGWINCH, i.e.
+        window resize signals. And it also sets id to 1.
+        """
+        base.AcquireProgress.start(self)
+        self._signal = signal.signal(signal.SIGWINCH, self._winch)
+        # Get the window size.
+        self._winch()
+        self._id = 1
+
+    def _winch(self, *dummy):
+        # type: (object) -> None
+        """Signal handler for window resize signals."""
+        if hasattr(self._file, "fileno") and os.isatty(self._file.fileno()):
+            import fcntl
+            import termios
+            import struct
+            buf = fcntl.ioctl(self._file, termios.TIOCGWINSZ, 8 * b' ')  # noqa
+            dummy, col, dummy, dummy = struct.unpack('hhhh', buf)
+            self._width = col - 1  # 1 for the cursor
+
+    def ims_hit(self, item):
+        # type: (apt_pkg.AcquireItemDesc) -> None
+        """Called when an item is update (e.g. not modified on the server)."""
+        base.AcquireProgress.ims_hit(self, item)
+        line = _('Hit ') + item.description
+        if item.owner.filesize:
+            line += ' [%sB]' % apt_pkg.size_to_str(item.owner.filesize)
+        self._write(line)
+
+    def fail(self, item):
+        # type: (apt_pkg.AcquireItemDesc) -> None
+        """Called when an item is failed."""
+        base.AcquireProgress.fail(self, item)
+        if item.owner.status == item.owner.STAT_DONE:
+            self._write(_("Ign ") + item.description)
+        else:
+            self._write(_("Err ") + item.description)
+            self._write("  %s" % item.owner.error_text)
+
+    def fetch(self, item):
+        # type: (apt_pkg.AcquireItemDesc) -> None
+        """Called when some of the item's data is fetched."""
+        base.AcquireProgress.fetch(self, item)
+        # It's complete already (e.g. Hit)
+        if item.owner.complete:
+            return
+        item.owner.id = self._id
+        self._id += 1
+        line = _("Get:") + "%s %s" % (item.owner.id, item.description)
+        if item.owner.filesize:
+            line += (" [%sB]" % apt_pkg.size_to_str(item.owner.filesize))
+
+        self._write(line)
+
+    def pulse(self, owner):
+        # type: (apt_pkg.Acquire) -> bool
+        """Periodically invoked while the Acquire process is underway.
+
+        Return False if the user asked to cancel the whole Acquire process."""
+        base.AcquireProgress.pulse(self, owner)
+        # only show progress on a tty to not clutter log files etc
+        if (hasattr(self._file, "fileno") and
+                not os.isatty(self._file.fileno())):
+            return True
+
+        # calculate progress
+        percent = (((self.current_bytes + self.current_items) * 100.0) /
+                        float(self.total_bytes + self.total_items))
+
+        shown = False
+        tval = '%i%%' % percent
+        end = ""
+        if self.current_cps:
+            eta = int(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))
+
+        for worker in owner.workers:
+            val = ''
+            if not worker.current_item:
+                if worker.status:
+                    val = ' [%s]' % worker.status
+                    if len(tval) + len(val) + len(end) >= self._width:
+                        break
+                    tval += val
+                    shown = True
+                continue
+            shown = True
+
+            if worker.current_item.owner.id:
+                val += " [%i %s" % (worker.current_item.owner.id,
+                                    worker.current_item.shortdesc)
+            else:
+                val += ' [%s' % worker.current_item.description
+            if worker.current_item.owner.active_subprocess:
+                val += ' %s' % worker.current_item.owner.active_subprocess
+
+            val += ' %sB' % apt_pkg.size_to_str(worker.current_size)
+
+            # Add the total size and percent
+            if worker.total_size and not worker.current_item.owner.complete:
+                val += "/%sB %i%%" % (
+                    apt_pkg.size_to_str(worker.total_size),
+                    worker.current_size * 100.0 / worker.total_size)
+
+            val += ']'
+
+            if len(tval) + len(val) + len(end) >= self._width:
+                # Display as many items as screen width
+                break
+            else:
+                tval += val
+
+        if not shown:
+            tval += _(" [Working]")
+
+        if self.current_cps:
+            tval += (self._width - len(end) - len(tval)) * ' ' + end
+
+        self._write(tval, False)
+        return True
+
+    def media_change(self, medium, drive):
+        # type: (str, str) -> bool
+        """Prompt the user to change the inserted removable media."""
+        base.AcquireProgress.media_change(self, medium, drive)
+        self._write(_("Media change: please insert the disc labeled\n"
+                      " '%s'\n"
+                      "in the drive '%s' and press enter\n") % (medium, drive))
+        return input() not in ('c', 'C')
+
+    def stop(self):
+        # type: () -> None
+        """Invoked when the Acquire process stops running."""
+        base.AcquireProgress.stop(self)
+        # Trick for getting a translation from apt
+        self._write((_("Fetched %sB in %s (%sB/s)\n") % (
+                    apt_pkg.size_to_str(self.fetched_bytes),
+                    apt_pkg.time_to_str(self.elapsed_time),
+                    apt_pkg.size_to_str(self.current_cps))).rstrip("\n"))
+
+        # Delete the signal again.
+        import signal
+        signal.signal(signal.SIGWINCH, self._signal)
+
+
+class CdromProgress(base.CdromProgress, TextProgress):
+    """Text CD-ROM progress."""
+
+    def ask_cdrom_name(self):
+        # type: () -> Optional[str]
+        """Ask the user to provide a name for the disc."""
+        base.CdromProgress.ask_cdrom_name(self)
+        self._write(_("Please provide a name for this medium, such as "
+                      "'Debian 2.1r1 Disk 1'"), False)
+        try:
+            return str(input(":"))
+        except KeyboardInterrupt:
+            return None
+
+    def update(self, text, current):
+        # type: (str, int) -> None
+        """Set the current progress."""
+        base.CdromProgress.update(self, text, current)
+        if text:
+            self._write(text, False)
+
+    def change_cdrom(self):
+        # type: () -> bool
+        """Ask the user to change the CD-ROM."""
+        base.CdromProgress.change_cdrom(self)
+        self._write(_("Please insert an installation medium and press enter"),
+                    False)
+        try:
+            return bool(input() == '')
+        except KeyboardInterrupt:
+            return False

apt/utils.py

@@ -0,0 +1,99 @@
+# Copyright (C) 2009 Canonical
+#
+# Authors:
+#  Michael Vogt
+#
+#  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.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+from __future__ import print_function
+
+import datetime
+import os
+
+from typing import Optional, Tuple
+
+import apt
+import apt_pkg
+
+
+def get_maintenance_end_date(release_date, m_months):
+    # type: (datetime.datetime, int) -> Tuple[int, int]
+    """
+    get the (year, month) tuple when the maintenance for the distribution
+    ends. Needs the data of the release and the number of months that
+    its is supported as input
+    """
+    # calc end date
+    years = m_months // 12
+    months = m_months % 12
+    support_end_year = (release_date.year + years +
+                        (release_date.month + months) // 12)
+    support_end_month = (release_date.month + months) % 12
+    # special case: this happens when e.g. doing 2010-06 + 18 months
+    if support_end_month == 0:
+        support_end_month = 12
+        support_end_year -= 1
+    return (support_end_year, support_end_month)
+
+
+def get_release_date_from_release_file(path):
+    # type: (str) -> Optional[int]
+    """
+    return the release date as time_t for the given release file
+    """
+    if not path or not os.path.exists(path):
+        return None
+
+    with os.fdopen(apt_pkg.open_maybe_clear_signed_file(path)) as data:
+        tag = apt_pkg.TagFile(data)
+        section = next(tag)
+        if "Date" not in section:
+            return None
+        date = section["Date"]
+        return apt_pkg.str_to_time(date)
+
+
+def get_release_filename_for_pkg(cache, pkgname, label, release):
+    # type: (apt.Cache, str, str, str) -> Optional[str]
+    " get the release file that provides this pkg "
+    if pkgname not in cache:
+        return None
+    pkg = cache[pkgname]
+    ver = None
+    # look for the version that comes from the repos with
+    # the given label and origin
+    for aver in pkg._pkg.version_list:
+        if aver is None or aver.file_list is None:
+            continue
+        for ver_file, _index in aver.file_list:
+            # print verFile
+            if (ver_file.origin == label and
+                    ver_file.label == label and
+                    ver_file.archive == release):
+                ver = aver
+    if not ver:
+        return None
+    indexfile = cache._list.find_index(ver.file_list[0][0])
+    for metaindex in cache._list.list:
+        for m in metaindex.index_files:
+            if (indexfile and
+                    indexfile.describe == m.describe and
+                    indexfile.is_trusted):
+                dirname = apt_pkg.config.find_dir("Dir::State::lists")
+                for relfile in ['InRelease', 'Release']:
+                    name = (apt_pkg.uri_to_filename(metaindex.uri) +
+                            "dists_%s_%s" % (metaindex.dist, relfile))
+                    if os.path.exists(dirname + name):
+                        return dirname + name
+    return None

aptsources/__init__.py

@@ -0,0 +1,9 @@
+from __future__ import print_function
+
+import apt_pkg
+
+
+# init the package system, but do not re-initialize config
+if "APT" not in apt_pkg.config:
+    apt_pkg.init_config()
+apt_pkg.init_system()

aptsources/distinfo.py

@@ -0,0 +1,393 @@
+#  distinfo.py - provide meta information for distro repositories
+#
+#  Copyright (c) 2005 Gustavo Noronha Silva <[email protected]>
+#  Copyright (c) 2006-2007 Sebastian Heinlein <[email protected]>
+#
+#  Authors: Gustavo Noronha Silva <[email protected]>
+#           Sebastian Heinlein <[email protected]>
+#
+#  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
+
+from __future__ import print_function
+
+import csv
+import errno
+import logging
+import os
+from subprocess import Popen, PIPE
+import re
+
+import apt_pkg
+
+from apt_pkg import gettext as _
+
+
+def _expand_template(template, csv_path):
+    """Expand the given template.
+
+    A template file consists of a header, followed by paragraphs
+    of templated suites, followed by a footer. A templated suite
+    is any paragraph where the Suite field contains {.
+
+    This function expands all templated suites using the information
+    found in the CSV file supplied by distro-info-data.
+
+    It yields lines of template info.
+    """
+
+    known_suites = set()
+
+    # Copy out any header, and gather all hardcoded suites
+    with apt_pkg.TagFile(template) as tmpl:
+        for section in tmpl:
+            if "X-Exclude-Suites" in section:
+                known_suites.update(section["X-Exclude-Suites"].split(", "))
+            if "Suite" in section:
+                if "{" in section["Suite"]:
+                    break
+
+                known_suites.add(section["Suite"])
+
+            yield from str(section).splitlines()
+        else:
+            # We did not break, so we did copy all of them
+            return
+
+        for section in tmpl:
+            if "Suite" in section:
+                known_suites.add(section["Suite"])
+
+    with open(csv_path) as csv_object:
+        releases = reversed(list(csv.DictReader(csv_object)))
+
+    # Perform template substitution on the middle of the list
+    for rel in releases:
+        if rel["series"] in known_suites:
+            continue
+        yield ""
+        rel["version"] = rel["version"].replace(" LTS", "")
+        with apt_pkg.TagFile(template) as tmpl:
+            for section in tmpl:
+                # Only work on template sections, this skips head and tails
+                if "Suite" not in section or "{" not in section["Suite"]:
+                    continue
+                if "X-Version" in section:
+                    # Version requirements. Maybe should be made nicer
+                    ver = rel["version"]
+                    if any(
+                            (field.startswith("le") and
+                             apt_pkg.version_compare(field[3:], ver) < 0) or
+                            (field.startswith("ge") and
+                             apt_pkg.version_compare(field[3:], ver) > 0)
+                            for field in section["X-Version"].split(", ")):
+                        continue
+
+                for line in str(section).format(**rel).splitlines():
+                    if line.startswith("X-Version"):
+                        continue
+                    yield line
+
+    # Copy out remaining suites
+    with apt_pkg.TagFile(template) as tmpl:
+        # Skip the head again, we don't want to copy it twice
+        for section in tmpl:
+            if "Suite" in section and "{" in section["Suite"]:
+                break
+
+        for section in tmpl:
+            # Ignore any template parts and copy the rest out,
+            # this is the inverse of the template substitution loop
+            if "Suite" in section and "{" in section["Suite"]:
+                continue
+
+            yield from str(section).splitlines()
+
+
+class Template(object):
+
+    def __init__(self):
+        self.name = None
+        self.child = False
+        self.parents = []          # ref to parent template(s)
+        self.match_name = None
+        self.description = None
+        self.base_uri = None
+        self.type = None
+        self.components = []
+        self.children = []
+        self.match_uri = None
+        self.mirror_set = {}
+        self.distribution = None
+        self.available = True
+        self.official = True
+
+    def has_component(self, comp):
+        ''' Check if the distribution provides the given component '''
+        return comp in (c.name for c in self.components)
+
+    def is_mirror(self, url):
+        ''' Check if a given url of a repository is a valid mirror '''
+        proto, hostname, dir = split_url(url)
+        if hostname in self.mirror_set:
+            return self.mirror_set[hostname].has_repository(proto, dir)
+        else:
+            return False
+
+
+class Component(object):
+
+    def __init__(self, name, desc=None, long_desc=None, parent_component=None):
+        self.name = name
+        self.description = desc
+        self.description_long = long_desc
+        self.parent_component = parent_component
+
+    def get_parent_component(self):
+        return self.parent_component
+
+    def set_parent_component(self, parent):
+        self.parent_component = parent
+
+    def get_description(self):
+        if self.description_long is not None:
+            return self.description_long
+        elif self.description is not None:
+            return self.description
+        else:
+            return None
+
+    def set_description(self, desc):
+        self.description = desc
+
+    def set_description_long(self, desc):
+        self.description_long = desc
+
+    def get_description_long(self):
+        return self.description_long
+
+
+class Mirror(object):
+    ''' Storage for mirror related information '''
+
+    def __init__(self, proto, hostname, dir, location=None):
+        self.hostname = hostname
+        self.repositories = []
+        self.add_repository(proto, dir)
+        self.location = location
+
+    def add_repository(self, proto, dir):
+        self.repositories.append(Repository(proto, dir))
+
+    def get_repositories_for_proto(self, proto):
+        return [r for r in self.repositories if r.proto == proto]
+
+    def has_repository(self, proto, dir):
+        if dir is None:
+            return False
+        for r in self.repositories:
+            if r.proto == proto and dir in r.dir:
+                return True
+        return False
+
+    def get_repo_urls(self):
+        return [r.get_url(self.hostname) for r in self.repositories]
+
+    def get_location(self):
+        return self.location
+
+    def set_location(self, location):
+        self.location = location
+
+
+class Repository(object):
+
+    def __init__(self, proto, dir):
+        self.proto = proto
+        self.dir = dir
+
+    def get_info(self):
+        return self.proto, self.dir
+
+    def get_url(self, hostname):
+        return "%s://%s/%s" % (self.proto, hostname, self.dir)
+
+
+def split_url(url):
+    ''' split a given URL into the protocoll, the hostname and the dir part '''
+    split = re.split(":*\\/+", url, maxsplit=2)
+    while len(split) < 3:
+        split.append(None)
+    return split
+
+
+class DistInfo(object):
+
+    def __init__(self, dist=None, base_dir="/usr/share/python-apt/templates"):
+        self.metarelease_uri = ''
+        self.templates = []
+        self.arch = apt_pkg.config.find("APT::Architecture")
+
+        location = None
+        match_loc = re.compile(r"^#LOC:(.+)$")
+        match_mirror_line = re.compile(
+            r"^(#LOC:.+)|(((http)|(ftp)|(rsync)|(file)|(mirror)|(https))://"
+            r"[A-Za-z0-9/\.:\-_@]+)$")
+        #match_mirror_line = re.compile(r".+")
+
+        if not dist:
+            try:
+                dist = Popen(["lsb_release", "-i", "-s"],
+                             universal_newlines=True,
+                             stdout=PIPE).communicate()[0].strip()
+            except (OSError, IOError) as exc:
+                if exc.errno != errno.ENOENT:
+                    logging.warning(
+                        'lsb_release failed, using defaults:' % exc)
+                dist = "Debian"
+
+        self.dist = dist
+
+        map_mirror_sets = {}
+
+        dist_fname = "%s/%s.info" % (base_dir, dist)
+        csv_fname = "/usr/share/distro-info/{}.csv".format(dist.lower())
+
+        template = None
+        component = None
+        for line in _expand_template(dist_fname, csv_fname):
+            tokens = line.split(':', 1)
+            if len(tokens) < 2:
+                continue
+            field = tokens[0].strip()
+            value = tokens[1].strip()
+            if field == 'ChangelogURI':
+                self.changelogs_uri = _(value)
+            elif field == 'MetaReleaseURI':
+                self.metarelease_uri = value
+            elif field == 'Suite':
+                self.finish_template(template, component)
+                component = None
+                template = Template()
+                template.name = value
+                template.distribution = dist
+                template.match_name = "^%s$" % value
+            elif field == 'MatchName':
+                template.match_name = value
+            elif field == 'ParentSuite':
+                template.child = True
+                for nanny in self.templates:
+                    # look for parent and add back ref to it
+                    if nanny.name == value:
+                        template.parents.append(nanny)
+                        nanny.children.append(template)
+            elif field == 'Available':
+                template.available = apt_pkg.string_to_bool(value)
+            elif field == 'Official':
+                template.official = apt_pkg.string_to_bool(value)
+            elif field == 'RepositoryType':
+                template.type = value
+            elif field == 'BaseURI' and not template.base_uri:
+                template.base_uri = value
+            elif field == 'BaseURI-%s' % self.arch:
+                template.base_uri = value
+            elif field == 'MatchURI' and not template.match_uri:
+                template.match_uri = value
+            elif field == 'MatchURI-%s' % self.arch:
+                template.match_uri = value
+            elif (field == 'MirrorsFile' or
+                  field == 'MirrorsFile-%s' % self.arch):
+                # Make the path absolute.
+                value = os.path.isabs(value) and value or \
+                        os.path.abspath(os.path.join(base_dir, value))
+                if value not in map_mirror_sets:
+                    mirror_set = {}
+                    try:
+                        with open(value) as value_f:
+                            mirror_data = list(filter(
+                                match_mirror_line.match,
+                                [x.strip() for x in value_f]))
+                    except Exception:
+                        print("WARNING: Failed to read mirror file")
+                        mirror_data = []
+                    for line in mirror_data:
+                        if line.startswith("#LOC:"):
+                            location = match_loc.sub(r"\1", line)
+                            continue
+                        (proto, hostname, dir) = split_url(line)
+                        if hostname in mirror_set:
+                            mirror_set[hostname].add_repository(proto, dir)
+                        else:
+                            mirror_set[hostname] = Mirror(
+                                proto, hostname, dir, location)
+                    map_mirror_sets[value] = mirror_set
+                template.mirror_set = map_mirror_sets[value]
+            elif field == 'Description':
+                template.description = _(value)
+            elif field == 'Component':
+                if (component and not
+                        template.has_component(component.name)):
+                    template.components.append(component)
+                component = Component(value)
+            elif field == 'CompDescription':
+                component.set_description(_(value))
+            elif field == 'CompDescriptionLong':
+                component.set_description_long(_(value))
+            elif field == 'ParentComponent':
+                component.set_parent_component(value)
+        self.finish_template(template, component)
+        template = None
+        component = None
+
+    def finish_template(self, template, component):
+        " finish the current tempalte "
+        if not template:
+            return
+        # reuse some properties of the parent template
+        if template.match_uri is None and template.child:
+            for t in template.parents:
+                if t.match_uri:
+                    template.match_uri = t.match_uri
+                    break
+        if template.mirror_set == {} and template.child:
+            for t in template.parents:
+                if t.match_uri:
+                    template.mirror_set = t.mirror_set
+                    break
+        if component and not template.has_component(component.name):
+            template.components.append(component)
+            component = None
+        # the official attribute is inherited
+        for t in template.parents:
+            template.official = t.official
+        self.templates.append(template)
+
+
+if __name__ == "__main__":
+    d = DistInfo("Ubuntu", "/usr/share/python-apt/templates")
+    logging.info(d.changelogs_uri)
+    for template in d.templates:
+        logging.info("\nSuite: %s" % template.name)
+        logging.info("Desc: %s" % template.description)
+        logging.info("BaseURI: %s" % template.base_uri)
+        logging.info("MatchURI: %s" % template.match_uri)
+        if template.mirror_set != {}:
+            logging.info("Mirrors: %s" % list(template.mirror_set.keys()))
+        for comp in template.components:
+            logging.info(" %s -%s -%s" % (comp.name,
+                                          comp.description,
+                                          comp.description_long))
+        for child in template.children:
+            logging.info("  %s" % child.description)

aptsources/distro.py

@@ -0,0 +1,613 @@
+#  distro.py - Provide a distro abstraction of the sources.list
+#
+#  Copyright (c) 2004-2009 Canonical Ltd.
+#  Copyright (c) 2006-2007 Sebastian Heinlein
+#  Copyright (c) 2016 Harald Sitter
+#
+#  Authors: Sebastian Heinlein <[email protected]>
+#           Michael Vogt <[email protected]>
+#           Harald Sitter <[email protected]>
+#
+#  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
+
+import gettext
+import logging
+import re
+import shlex
+import os
+
+from xml.etree.ElementTree import ElementTree
+
+from apt_pkg import gettext as _
+
+
+class NoDistroTemplateException(Exception):
+    pass
+
+
+class Distribution(object):
+
+    def __init__(self, id, codename, description, release, is_like=[]):
+        """ Container for distribution specific informations """
+        # LSB information
+        self.id = id
+        self.codename = codename
+        self.description = description
+        self.release = release
+        self.is_like = is_like
+
+        self.binary_type = "deb"
+        self.source_type = "deb-src"
+
+    def get_sources(self, sourceslist):
+        """
+        Find the corresponding template, main and child sources
+        for the distribution
+        """
+
+        self.sourceslist = sourceslist
+        # corresponding sources
+        self.source_template = None
+        self.child_sources = []
+        self.main_sources = []
+        self.disabled_sources = []
+        self.cdrom_sources = []
+        self.download_comps = []
+        self.enabled_comps = []
+        self.cdrom_comps = []
+        self.used_media = []
+        self.get_source_code = False
+        self.source_code_sources = []
+
+        # location of the sources
+        self.default_server = ""
+        self.main_server = ""
+        self.nearest_server = ""
+        self.used_servers = []
+
+        # find the distro template
+        for template in self.sourceslist.matcher.templates:
+            if (self.is_codename(template.name) and
+                    template.distribution == self.id):
+                #print "yeah! found a template for %s" % self.description
+                #print template.description, template.base_uri, \
+                #    template.components
+                self.source_template = template
+                break
+        if self.source_template is None:
+            raise NoDistroTemplateException(
+                "Error: could not find a distribution template for %s/%s" %
+                (self.id, self.codename))
+
+        # find main and child sources
+        media = []
+        comps = []
+        cdrom_comps = []
+        enabled_comps = []
+        #source_code = []
+        for source in self.sourceslist.list:
+            if (not source.invalid and
+                    self.is_codename(source.dist) and
+                    source.template and
+                    source.template.official and
+                    self.is_codename(source.template.name)):
+                #print "yeah! found a distro repo:  %s" % source.line
+                # cdroms need do be handled differently
+                if (source.uri.startswith("cdrom:") and
+                        not source.disabled):
+                    self.cdrom_sources.append(source)
+                    cdrom_comps.extend(source.comps)
+                elif (source.uri.startswith("cdrom:") and
+                          source.disabled):
+                    self.cdrom_sources.append(source)
+                elif (source.type == self.binary_type and
+                          not source.disabled):
+                    self.main_sources.append(source)
+                    comps.extend(source.comps)
+                    media.append(source.uri)
+                elif (source.type == self.binary_type and
+                          source.disabled):
+                    self.disabled_sources.append(source)
+                elif (source.type == self.source_type and
+                          not source.disabled):
+                    self.source_code_sources.append(source)
+                elif (source.type == self.source_type and
+                          source.disabled):
+                    self.disabled_sources.append(source)
+            if (not source.invalid and
+                    source.template in self.source_template.children):
+                if (not source.disabled and
+                    source.type == self.binary_type):
+                    self.child_sources.append(source)
+                elif (not source.disabled and
+                      source.type == self.source_type):
+                    self.source_code_sources.append(source)
+                else:
+                    self.disabled_sources.append(source)
+        self.download_comps = set(comps)
+        self.cdrom_comps = set(cdrom_comps)
+        enabled_comps.extend(comps)
+        enabled_comps.extend(cdrom_comps)
+        self.enabled_comps = set(enabled_comps)
+        self.used_media = set(media)
+        self.get_mirrors()
+
+    def get_mirrors(self, mirror_template=None):
+        """
+        Provide a set of mirrors where you can get the distribution from
+        """
+        # the main server is stored in the template
+        self.main_server = self.source_template.base_uri
+
+        # other used servers
+        for medium in self.used_media:
+            if not medium.startswith("cdrom:"):
+                # seems to be a network source
+                self.used_servers.append(medium)
+
+        if len(self.main_sources) == 0:
+            self.default_server = self.main_server
+        else:
+            self.default_server = self.main_sources[0].uri
+
+        # get a list of country codes and real names
+        self.countries = {}
+        fname = "/usr/share/xml/iso-codes/iso_3166.xml"
+        if os.path.exists(fname):
+            et = ElementTree(file=fname)
+            # python2.6 compat, the next two lines can get removed
+            # once we do not use py2.6 anymore
+            if getattr(et, "iter", None) is None:
+                et.iter = et.getiterator
+            it = et.iter('iso_3166_entry')
+            for elm in it:
+                try:
+                    descr = elm.attrib["common_name"]
+                except KeyError:
+                    descr = elm.attrib["name"]
+                try:
+                    code = elm.attrib["alpha_2_code"]
+                except KeyError:
+                    code = elm.attrib["alpha_3_code"]
+                self.countries[code.lower()] = gettext.dgettext('iso_3166',
+                                                                descr)
+
+        # try to guess the nearest mirror from the locale
+        self.country = None
+        self.country_code = None
+        locale = os.getenv("LANG", default="en_UK")
+        a = locale.find("_")
+        z = locale.find(".")
+        if z == -1:
+            z = len(locale)
+        country_code = locale[a + 1:z].lower()
+
+        if mirror_template:
+            self.nearest_server = mirror_template % country_code
+
+        if country_code in self.countries:
+            self.country = self.countries[country_code]
+            self.country_code = country_code
+
+    def _get_mirror_name(self, server):
+        ''' Try to get a human readable name for the main mirror of a country
+            Customize for different distributions '''
+        country = None
+        i = server.find("://")
+        li = server.find(".archive.ubuntu.com")
+        if i != -1 and li != -1:
+            country = server[i + len("://"):li]
+        if country in self.countries:
+            # TRANSLATORS: %s is a country
+            return _("Server for %s") % self.countries[country]
+        else:
+            return("%s" % server.rstrip("/ "))
+
+    def get_server_list(self):
+        ''' Return a list of used and suggested servers '''
+
+        def compare_mirrors(mir1, mir2):
+            ''' Helper function that handles comaprision of mirror urls
+                that could contain trailing slashes'''
+            return re.match(mir1.strip("/ "), mir2.rstrip("/ "))
+
+        # Store all available servers:
+        # Name, URI, active
+        mirrors = []
+        if (len(self.used_servers) < 1 or
+            (len(self.used_servers) == 1 and
+             compare_mirrors(self.used_servers[0], self.main_server))):
+            mirrors.append([_("Main server"), self.main_server, True])
+            if self.nearest_server:
+                mirrors.append([self._get_mirror_name(self.nearest_server),
+                                self.nearest_server, False])
+        elif (len(self.used_servers) == 1 and not
+              compare_mirrors(self.used_servers[0], self.main_server)):
+            mirrors.append([_("Main server"), self.main_server, False])
+            # Only one server is used
+            server = self.used_servers[0]
+
+            # Append the nearest server if it's not already used
+            if self.nearest_server:
+                if not compare_mirrors(server, self.nearest_server):
+                    mirrors.append([self._get_mirror_name(self.nearest_server),
+                                    self.nearest_server, False])
+            if server:
+                mirrors.append([self._get_mirror_name(server), server, True])
+
+        elif len(self.used_servers) > 1:
+            # More than one server is used. Since we don't handle this case
+            # in the user interface we set "custom servers" to true and
+            # append a list of all used servers
+            mirrors.append([_("Main server"), self.main_server, False])
+            if self.nearest_server:
+                mirrors.append([self._get_mirror_name(self.nearest_server),
+                                self.nearest_server, False])
+            mirrors.append([_("Custom servers"), None, True])
+            for server in self.used_servers:
+                mirror_entry = [self._get_mirror_name(server), server, False]
+                if (compare_mirrors(server, self.nearest_server) or
+                        compare_mirrors(server, self.main_server)):
+                    continue
+                elif mirror_entry not in mirrors:
+                    mirrors.append(mirror_entry)
+
+        return mirrors
+
+    def add_source(self, type=None,
+                 uri=None, dist=None, comps=None, comment=""):
+        """
+        Add distribution specific sources
+        """
+        if uri is None:
+            # FIXME: Add support for the server selector
+            uri = self.default_server
+        if dist is None:
+            dist = self.codename
+        if comps is None:
+            comps = list(self.enabled_comps)
+        if type is None:
+            type = self.binary_type
+        new_source = self.sourceslist.add(type, uri, dist, comps, comment)
+        # if source code is enabled add a deb-src line after the new
+        # source
+        if self.get_source_code and type == self.binary_type:
+            self.sourceslist.add(
+                self.source_type, uri, dist, comps, comment,
+                file=new_source.file,
+                pos=self.sourceslist.list.index(new_source) + 1)
+
+    def enable_component(self, comp):
+        """
+        Enable a component in all main, child and source code sources
+        (excluding cdrom based sources)
+
+        comp:         the component that should be enabled
+        """
+        comps = set([comp])
+        # look for parent components that we may have to add
+        for source in self.main_sources:
+            for c in source.template.components:
+                if c.name == comp and c.parent_component:
+                    comps.add(c.parent_component)
+        for c in comps:
+            self._enable_component(c)
+
+    def _enable_component(self, comp):
+
+        def add_component_only_once(source, comps_per_dist):
+            """
+            Check if we already added the component to the repository, since
+            a repository could be splitted into different apt lines. If not
+            add the component
+            """
+            # if we don't have that distro, just return (can happen for e.g.
+            # dapper-update only in deb-src
+            if source.dist not in comps_per_dist:
+                return
+            # if we have seen this component already for this distro,
+            # return (nothing to do)
+            if comp in comps_per_dist[source.dist]:
+                return
+            # add it
+            source.comps.append(comp)
+            comps_per_dist[source.dist].add(comp)
+
+        sources = []
+        sources.extend(self.main_sources)
+        sources.extend(self.child_sources)
+        # store what comps are enabled already per distro (where distro is
+        # e.g. "dapper", "dapper-updates")
+        comps_per_dist = {}
+        comps_per_sdist = {}
+        for s in sources:
+            if s.type == self.binary_type:
+                if s.dist not in comps_per_dist:
+                    comps_per_dist[s.dist] = set()
+                for c in s.comps:
+                    comps_per_dist[s.dist].add(c)
+        for s in self.source_code_sources:
+            if s.type == self.source_type:
+                if s.dist not in comps_per_sdist:
+                    comps_per_sdist[s.dist] = set()
+                for c in s.comps:
+                    comps_per_sdist[s.dist].add(c)
+
+        # check if there is a main source at all
+        if len(self.main_sources) < 1:
+            # create a new main source
+            self.add_source(comps=["%s" % comp])
+        else:
+            # add the comp to all main, child and source code sources
+            for source in sources:
+                add_component_only_once(source, comps_per_dist)
+
+            for source in self.source_code_sources:
+                add_component_only_once(source, comps_per_sdist)
+
+        # check if there is a main source code source at all
+        if self.get_source_code:
+            if len(self.source_code_sources) < 1:
+                # create a new main source
+                self.add_source(type=self.source_type, comps=["%s" % comp])
+            else:
+                # add the comp to all main, child and source code sources
+                for source in self.source_code_sources:
+                    add_component_only_once(source, comps_per_sdist)
+
+    def disable_component(self, comp):
+        """
+        Disable a component in all main, child and source code sources
+        (excluding cdrom based sources)
+        """
+        sources = []
+        sources.extend(self.main_sources)
+        sources.extend(self.child_sources)
+        sources.extend(self.source_code_sources)
+        if comp in self.cdrom_comps:
+            sources = []
+            sources.extend(self.main_sources)
+        for source in sources:
+            if comp in source.comps:
+                source.comps.remove(comp)
+                if len(source.comps) < 1:
+                    self.sourceslist.remove(source)
+
+    def change_server(self, uri):
+        ''' Change the server of all distro specific sources to
+            a given host '''
+
+        def change_server_of_source(source, uri, seen):
+            # Avoid creating duplicate entries
+            source.uri = uri
+            for comp in source.comps:
+                if [source.uri, source.dist, comp] in seen:
+                    source.comps.remove(comp)
+                else:
+                    seen.append([source.uri, source.dist, comp])
+            if len(source.comps) < 1:
+                self.sourceslist.remove(source)
+
+        seen_binary = []
+        seen_source = []
+        self.default_server = uri
+        for source in self.main_sources:
+            change_server_of_source(source, uri, seen_binary)
+        for source in self.child_sources:
+            # Do not change the forces server of a child source
+            if (source.template.base_uri is None or
+                    source.template.base_uri != source.uri):
+                change_server_of_source(source, uri, seen_binary)
+        for source in self.source_code_sources:
+            change_server_of_source(source, uri, seen_source)
+
+    def is_codename(self, name):
+        ''' Compare a given name with the release codename. '''
+        if name == self.codename:
+            return True
+        else:
+            return False
+
+
+class DebianDistribution(Distribution):
+    ''' Class to support specific Debian features '''
+
+    def is_codename(self, name):
+        ''' Compare a given name with the release codename and check if
+            if it can be used as a synonym for a development releases '''
+        if name == self.codename or self.release in ("testing", "unstable"):
+            return True
+        else:
+            return False
+
+    def _get_mirror_name(self, server):
+        ''' Try to get a human readable name for the main mirror of a country
+            Debian specific '''
+        country = None
+        i = server.find("://ftp.")
+        li = server.find(".debian.org")
+        if i != -1 and li != -1:
+            country = server[i + len("://ftp."):li]
+        if country in self.countries:
+            # TRANSLATORS: %s is a country
+            return _("Server for %s") % gettext.dgettext(
+                "iso_3166", self.countries[country].rstrip()).rstrip()
+        else:
+            return("%s" % server.rstrip("/ "))
+
+    def get_mirrors(self):
+        Distribution.get_mirrors(
+            self, mirror_template="http://ftp.%s.debian.org/debian/")
+
+
+class UbuntuDistribution(Distribution):
+    ''' Class to support specific Ubuntu features '''
+
+    def get_mirrors(self):
+        Distribution.get_mirrors(
+            self, mirror_template="http://%s.archive.ubuntu.com/ubuntu/")
+
+
+class UbuntuRTMDistribution(UbuntuDistribution):
+    ''' Class to support specific Ubuntu RTM features '''
+
+    def get_mirrors(self):
+        self.main_server = self.source_template.base_uri
+
+
+def _lsb_release():
+    """Call lsb_release --idrc and return a mapping."""
+    from subprocess import Popen, PIPE
+    import errno
+    result = {'Codename': 'sid', 'Distributor ID': 'Debian',
+              'Description': 'Debian GNU/Linux unstable (sid)',
+              'Release': 'unstable'}
+    try:
+        out = Popen(['lsb_release', '-idrc'], stdout=PIPE).communicate()[0]
+        # Convert to unicode string, needed for Python 3.1
+        out = out.decode("utf-8")
+        result.update(line.split(":\t") for line in out.split("\n")
+                                        if ':\t' in line)
+    except OSError as exc:
+        if exc.errno != errno.ENOENT:
+            logging.warning('lsb_release failed, using defaults:' % exc)
+    return result
+
+
+def _system_image_channel():
+    """Get the current channel from system-image-cli -i if possible."""
+    from subprocess import Popen, PIPE
+    import errno
+    try:
+        from subprocess import DEVNULL
+    except ImportError:
+        # no DEVNULL in 2.7
+        DEVNULL = os.open(os.devnull, os.O_RDWR)
+    try:
+        out = Popen(
+            ['system-image-cli', '-i'], stdout=PIPE, stderr=DEVNULL,
+            universal_newlines=True).communicate()[0]
+        for line in out.splitlines():
+            if line.startswith('channel: '):
+                return line.split(': ', 1)[1]
+    except OSError as exc:
+        if exc.errno != errno.ENOENT:
+            logging.warning(
+                'system-image-cli failed, using defaults: %s' % exc)
+    return None
+
+
+class _OSRelease:
+
+    DEFAULT_OS_RELEASE_FILE = '/etc/os-release'
+    OS_RELEASE_FILE = '/etc/os-release'
+
+    def __init__(self, lsb_compat=True):
+        self.result = {}
+        self.valid = False
+        self.file = _OSRelease.OS_RELEASE_FILE
+
+        if not os.path.isfile(self.file):
+            return
+
+        self.parse()
+        self.valid = True
+
+        if lsb_compat:
+            self.inject_lsb_compat()
+
+    def inject_lsb_compat(self):
+        self.result['Distributor ID'] = self.result['ID']
+        self.result['Description'] = self.result['PRETTY_NAME']
+        # Optionals as per os-release spec.
+        self.result['Codename'] = self.result.get('VERSION_CODENAME')
+        if not self.result['Codename']:
+            # Transient Ubuntu 16.04 field (LP: #1598212)
+            self.result['Codename'] = self.result.get('UBUNTU_CODENAME')
+        self.result['Release'] = self.result.get('VERSION_ID')
+
+    def parse(self):
+        f = open(self.file, 'r')
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            self.parse_entry(*line.split('=', 1))
+        f.close()
+
+    def parse_entry(self, key, value):
+        value = self.parse_value(value)  # Values can be shell strings...
+        if key == "ID_LIKE" and isinstance(value, str):
+            # ID_LIKE is specified as quoted space-separated list. This will
+            # be parsed as string that we need to split manually.
+            value = value.split(' ')
+        self.result[key] = value
+
+    def parse_value(self, value):
+        values = shlex.split(value)
+        if len(values) == 1:
+            return values[0]
+        return values
+
+
+def get_distro(id=None, codename=None, description=None, release=None,
+               is_like=[]):
+    """
+    Check the currently used distribution and return the corresponding
+    distriubtion class that supports distro specific features.
+
+    If no paramter are given the distro will be auto detected via
+    a call to lsb-release
+    """
+    # make testing easier
+    if not (id and codename and description and release):
+        os_release = _OSRelease()
+        os_result = []
+        lsb_result = _lsb_release()
+        if os_release.valid:
+            os_result = os_release.result
+        # TODO: We cannot presently use os-release to fully replace lsb_release
+        #       because os-release's ID, VERSION_ID and VERSION_CODENAME fields
+        #       are specified as lowercase. In lsb_release they can be upcase
+        #       or captizalized. So, switching to os-release would consitute
+        #       a behavior break a which point lsb_release support should be
+        #       fully removed.
+        #       This in particular is a problem for template matching, as this
+        #       matches against Distribution objects and depends on string
+        #       case.
+        lsb_result = _lsb_release()
+        id = lsb_result['Distributor ID']
+        codename = lsb_result['Codename']
+        description = lsb_result['Description']
+        release = lsb_result['Release']
+        # Not available with LSB, use get directly.
+        is_like = os_result.get('ID_LIKE', [])
+        if id == "Ubuntu":
+            channel = _system_image_channel()
+            if channel is not None and "ubuntu-rtm/" in channel:
+                id = "Ubuntu-RTM"
+                codename = channel.rsplit("/", 1)[1].split("-", 1)[0]
+                description = codename
+                release = codename
+    if id == "Ubuntu":
+        return UbuntuDistribution(id, codename, description, release, is_like)
+    if id == "Ubuntu-RTM":
+        return UbuntuRTMDistribution(
+            id, codename, description, release, is_like)
+    elif id == "Debian":
+        return DebianDistribution(id, codename, description, release, is_like)
+    else:
+        return Distribution(id, codename, description, release, is_like)

aptsources/sourceslist.py

@@ -0,0 +1,516 @@
+#  sourceslist.py - Provide an abstraction of the sources.list
+#
+#  Copyright (c) 2004-2009 Canonical Ltd.
+#  Copyright (c) 2004 Michiel Sikkes
+#  Copyright (c) 2006-2007 Sebastian Heinlein
+#
+#  Authors: Michiel Sikkes <[email protected]>
+#           Michael Vogt <[email protected]>
+#           Sebastian Heinlein <[email protected]>
+#
+#  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
+
+from __future__ import absolute_import, print_function
+
+import glob
+import logging
+import os.path
+import re
+import shutil
+import time
+
+import apt_pkg
+from .distinfo import DistInfo
+#from apt_pkg import gettext as _
+
+
+# some global helpers
+
+__all__ = ['is_mirror', 'SourceEntry', 'NullMatcher', 'SourcesList',
+           'SourceEntryMatcher']
+
+
+def is_mirror(master_uri, compare_uri):
+    """ check if the given add_url is idential or a mirror of orig_uri e.g.:
+        master_uri = archive.ubuntu.com
+        compare_uri = de.archive.ubuntu.com
+        -> True
+    """
+    # remove traling spaces and "/"
+    compare_uri = compare_uri.rstrip("/ ")
+    master_uri = master_uri.rstrip("/ ")
+    # uri is identical
+    if compare_uri == master_uri:
+        #print "Identical"
+        return True
+    # add uri is a master site and orig_uri has the from "XX.mastersite"
+    # (e.g. de.archive.ubuntu.com)
+    try:
+        compare_srv = compare_uri.split("//")[1]
+        master_srv = master_uri.split("//")[1]
+        #print "%s == %s " % (add_srv, orig_srv)
+    except IndexError:  # ok, somethings wrong here
+        #print "IndexError"
+        return False
+    # remove the leading "<country>." (if any) and see if that helps
+    if "." in compare_srv and \
+           compare_srv[compare_srv.index(".") + 1:] == master_srv:
+        #print "Mirror"
+        return True
+    return False
+
+
+def uniq(s):
+    """ simple and efficient way to return uniq collection
+
+    This is not intended for use with a SourceList. It is provided
+    for internal use only. It does not have a leading underscore to
+    not break any old code that uses it; but it should not be used
+    in new code (and is not listed in __all__)."""
+    return list(set(s))
+
+
+class SourceEntry(object):
+    """ single sources.list entry """
+
+    def __init__(self, line, file=None):
+        self.invalid = False         # is the source entry valid
+        self.disabled = False        # is it disabled ('#' in front)
+        self.type = ""               # what type (deb, deb-src)
+        self.architectures = []      # architectures
+        self.trusted = None          # Trusted
+        self.uri = ""                # base-uri
+        self.dist = ""               # distribution (dapper, edgy, etc)
+        self.comps = []              # list of available componetns (may empty)
+        self.comment = ""            # (optional) comment
+        self.line = line             # the original sources.list line
+        if file is None:
+            file = apt_pkg.config.find_dir(
+                "Dir::Etc") + apt_pkg.config.find("Dir::Etc::sourcelist")
+        self.file = file             # the file that the entry is located in
+        self.parse(line)
+        self.template = None         # type DistInfo.Suite
+        self.children = []
+
+    def __eq__(self, other):
+        """ equal operator for two sources.list entries """
+        return (self.disabled == other.disabled and
+                self.type == other.type and
+                self.uri.rstrip('/') == other.uri.rstrip('/') and
+                self.dist == other.dist and
+                self.comps == other.comps)
+
+    def mysplit(self, line):
+        """ a split() implementation that understands the sources.list
+            format better and takes [] into account (for e.g. cdroms) """
+        line = line.strip()
+        pieces = []
+        tmp = ""
+        # we are inside a [..] block
+        p_found = False
+        space_found = False
+        for i in range(len(line)):
+            if line[i] == "[":
+                if space_found:
+                    space_found = False
+                    p_found = True
+                    pieces.append(tmp)
+                    tmp = line[i]
+                else:
+                    p_found = True
+                    tmp += line[i]
+            elif line[i] == "]":
+                p_found = False
+                tmp += line[i]
+            elif space_found and not line[i].isspace():
+                # we skip one or more space
+                space_found = False
+                pieces.append(tmp)
+                tmp = line[i]
+            elif line[i].isspace() and not p_found:
+                # found a whitespace
+                space_found = True
+            else:
+                tmp += line[i]
+        # append last piece
+        if len(tmp) > 0:
+            pieces.append(tmp)
+        return pieces
+
+    def parse(self, line):
+        """ parse a given sources.list (textual) line and break it up
+            into the field we have """
+        self.line = line
+        line = line.strip()
+        # check if the source is enabled/disabled
+        if line == "" or line == "#":  # empty line
+            self.invalid = True
+            return
+        if line[0] == "#":
+            self.disabled = True
+            pieces = line[1:].strip().split()
+            # if it looks not like a disabled deb line return
+            if not pieces[0] in ("rpm", "rpm-src", "deb", "deb-src"):
+                self.invalid = True
+                return
+            else:
+                line = line[1:]
+        # check for another "#" in the line (this is treated as a comment)
+        i = line.find("#")
+        if i > 0:
+            self.comment = line[i + 1:]
+            line = line[:i]
+        # source is ok, split it and see what we have
+        pieces = self.mysplit(line)
+        # Sanity check
+        if len(pieces) < 3:
+            self.invalid = True
+            return
+        # Type, deb or deb-src
+        self.type = pieces[0].strip()
+        # Sanity check
+        if self.type not in ("deb", "deb-src", "rpm", "rpm-src"):
+            self.invalid = True
+            return
+
+        if pieces[1].strip()[0] == "[":
+            options = pieces.pop(1).strip("[]").split()
+            for option in options:
+                try:
+                    key, value = option.split("=", 1)
+                except Exception:
+                    self.invalid = True
+                else:
+                    if key == "arch":
+                        self.architectures = value.split(",")
+                    elif key == "trusted":
+                        self.trusted = apt_pkg.string_to_bool(value)
+                    else:
+                        self.invalid = True
+
+        # URI
+        self.uri = pieces[1].strip()
+        if len(self.uri) < 1:
+            self.invalid = True
+        # distro and components (optional)
+        # Directory or distro
+        self.dist = pieces[2].strip()
+        if len(pieces) > 3:
+            # List of components
+            self.comps = pieces[3:]
+        else:
+            self.comps = []
+
+    def set_enabled(self, new_value):
+        """ set a line to enabled or disabled """
+        self.disabled = not new_value
+        # enable, remove all "#" from the start of the line
+        if new_value:
+            self.line = self.line.lstrip().lstrip('#')
+        else:
+            # disabled, add a "#"
+            if self.line.strip()[0] != "#":
+                self.line = "#" + self.line
+
+    def __str__(self):
+        """ debug helper """
+        return self.str().strip()
+
+    def str(self):
+        """ return the current line as string """
+        if self.invalid:
+            return self.line
+        line = ""
+        if self.disabled:
+            line = "# "
+
+        line += self.type
+
+        if self.architectures and self.trusted is not None:
+            line += " [arch=%s trusted=%s]" % (
+                ",".join(self.architectures), "yes" if self.trusted else "no")
+        elif self.trusted is not None:
+            line += " [trusted=%s]" % ("yes" if self.trusted else "no")
+        elif self.architectures:
+            line += " [arch=%s]" % ",".join(self.architectures)
+        line += " %s %s" % (self.uri, self.dist)
+        if len(self.comps) > 0:
+            line += " " + " ".join(self.comps)
+        if self.comment != "":
+            line += " #" + self.comment
+        line += "\n"
+        return line
+
+
+class NullMatcher(object):
+    """ a Matcher that does nothing """
+
+    def match(self, s):
+        return True
+
+
+class SourcesList(object):
+    """ represents the full sources.list + sources.list.d file """
+
+    def __init__(self,
+                 withMatcher=True,
+                 matcherPath="/usr/share/python-apt/templates/"):
+        self.list = []          # the actual SourceEntries Type
+        if withMatcher:
+            self.matcher = SourceEntryMatcher(matcherPath)
+        else:
+            self.matcher = NullMatcher()
+        self.refresh()
+
+    def refresh(self):
+        """ update the list of known entries """
+        self.list = []
+        # read sources.list
+        file = apt_pkg.config.find_file("Dir::Etc::sourcelist")
+        if os.path.exists(file):
+            self.load(file)
+        # read sources.list.d
+        partsdir = apt_pkg.config.find_dir("Dir::Etc::sourceparts")
+        for file in glob.glob("%s/*.list" % partsdir):
+            self.load(file)
+        # check if the source item fits a predefined template
+        for source in self.list:
+            if not source.invalid:
+                self.matcher.match(source)
+
+    def __iter__(self):
+        """ simple iterator to go over self.list, returns SourceEntry
+            types """
+        for entry in self.list:
+            yield entry
+
+    def __find(self, *predicates, **attrs):
+        uri = attrs.pop('uri', None)
+        for source in self.list:
+            if uri and uri.rstrip('/') != source.uri.rstrip('/'):
+                continue
+            if (all(getattr(source, key) == attrs[key] for key in attrs) and
+                    all(predicate(source) for predicate in predicates)):
+                yield source
+
+    def add(self, type, uri, dist, orig_comps, comment="", pos=-1, file=None,
+            architectures=[]):
+        """
+        Add a new source to the sources.list.
+        The method will search for existing matching repos and will try to
+        reuse them as far as possible
+        """
+
+        type = type.strip()
+        disabled = type.startswith("#")
+        if disabled:
+            type = type[1:].lstrip()
+        architectures = set(architectures)
+        # create a working copy of the component list so that
+        # we can modify it later
+        comps = orig_comps[:]
+        sources = self.__find(lambda s: set(s.architectures) == architectures,
+                              disabled=disabled, invalid=False, type=type,
+                              uri=uri, dist=dist)
+        # check if we have this source already in the sources.list
+        for source in sources:
+            for new_comp in comps:
+                if new_comp in source.comps:
+                    # we have this component already, delete it
+                    # from the new_comps list
+                    del comps[comps.index(new_comp)]
+                    if len(comps) == 0:
+                        return source
+
+        sources = self.__find(lambda s: set(s.architectures) == architectures,
+                              invalid=False, type=type, uri=uri, dist=dist)
+        for source in sources:
+            if source.disabled == disabled:
+                # if there is a repo with the same (disabled, type, uri, dist)
+                # just add the components
+                if set(source.comps) != set(comps):
+                    source.comps = uniq(source.comps + comps)
+                return source
+            elif source.disabled and not disabled:
+                # enable any matching (type, uri, dist), but disabled repo
+                if set(source.comps) == set(comps):
+                    source.disabled = False
+                    return source
+        # there isn't any matching source, so create a new line and parse it
+        parts = [
+            "#" if disabled else "",
+            type,
+            ("[arch=%s]" % ",".join(architectures)) if architectures else "",
+            uri,
+            dist,
+        ]
+        parts.extend(comps)
+        if comment:
+            parts.append("#" + comment)
+        line = " ".join(part for part in parts if part) + "\n"
+
+        new_entry = SourceEntry(line)
+        if file is not None:
+            new_entry.file = file
+        self.matcher.match(new_entry)
+        if pos < 0:
+            self.list.append(new_entry)
+        else:
+            self.list.insert(pos, new_entry)
+        return new_entry
+
+    def remove(self, source_entry):
+        """ remove the specified entry from the sources.list """
+        self.list.remove(source_entry)
+
+    def restore_backup(self, backup_ext):
+        " restore sources.list files based on the backup extension "
+        file = apt_pkg.config.find_file("Dir::Etc::sourcelist")
+        if os.path.exists(file + backup_ext) and os.path.exists(file):
+            shutil.copy(file + backup_ext, file)
+        # now sources.list.d
+        partsdir = apt_pkg.config.find_dir("Dir::Etc::sourceparts")
+        for file in glob.glob("%s/*.list" % partsdir):
+            if os.path.exists(file + backup_ext):
+                shutil.copy(file + backup_ext, file)
+
+    def backup(self, backup_ext=None):
+        """ make a backup of the current source files, if no backup extension
+            is given, the current date/time is used (and returned) """
+        already_backuped = set()
+        if backup_ext is None:
+            backup_ext = time.strftime("%y%m%d.%H%M")
+        for source in self.list:
+            if (source.file not in already_backuped and
+                os.path.exists(source.file)):
+                shutil.copy(source.file, "%s%s" % (source.file, backup_ext))
+        return backup_ext
+
+    def load(self, file):
+        """ (re)load the current sources """
+        try:
+            with open(file, "r") as f:
+                for line in f:
+                    source = SourceEntry(line, file)
+                    self.list.append(source)
+        except Exception:
+            logging.warning("could not open file '%s'\n" % file)
+
+    def save(self):
+        """ save the current sources """
+        files = {}
+        # write an empty default config file if there aren't any sources
+        if len(self.list) == 0:
+            path = apt_pkg.config.find_file("Dir::Etc::sourcelist")
+            header = (
+                "## See sources.list(5) for more information, especialy\n"
+                "# Remember that you can only use http, ftp or file URIs\n"
+                "# CDROMs are managed through the apt-cdrom tool.\n")
+
+            with open(path, "w") as f:
+                f.write(header)
+            return
+
+        try:
+            for source in self.list:
+                if source.file not in files:
+                    files[source.file] = open(source.file, "w")
+                files[source.file].write(source.str())
+        finally:
+            for f in files:
+                files[f].close()
+
+    def check_for_relations(self, sources_list):
+        """get all parent and child channels in the sources list"""
+        parents = []
+        used_child_templates = {}
+        for source in sources_list:
+            # try to avoid checking uninterressting sources
+            if source.template is None:
+                continue
+            # set up a dict with all used child templates and corresponding
+            # source entries
+            if source.template.child:
+                key = source.template
+                if key not in used_child_templates:
+                    used_child_templates[key] = []
+                temp = used_child_templates[key]
+                temp.append(source)
+            else:
+                # store each source with children aka. a parent :)
+                if len(source.template.children) > 0:
+                    parents.append(source)
+        #print self.used_child_templates
+        #print self.parents
+        return (parents, used_child_templates)
+
+
+class SourceEntryMatcher(object):
+    """ matcher class to make a source entry look nice
+        lots of predefined matchers to make it i18n/gettext friendly
+        """
+
+    def __init__(self, matcherPath):
+        self.templates = []
+        # Get the human readable channel and comp names from the channel .infos
+        spec_files = glob.glob("%s/*.info" % matcherPath)
+        for f in spec_files:
+            f = os.path.basename(f)
+            i = f.find(".info")
+            f = f[0:i]
+            dist = DistInfo(f, base_dir=matcherPath)
+            for template in dist.templates:
+                if template.match_uri is not None:
+                    self.templates.append(template)
+        return
+
+    def match(self, source):
+        """Add a matching template to the source"""
+        found = False
+        for template in self.templates:
+            if (re.search(template.match_uri, source.uri) and
+                    re.match(template.match_name, source.dist) and
+                    # deb is a valid fallback for deb-src (if that is not
+                    # definied, see #760035
+                    (source.type == template.type or template.type == "deb")):
+                found = True
+                source.template = template
+                break
+            elif (template.is_mirror(source.uri) and
+                      re.match(template.match_name, source.dist)):
+                found = True
+                source.template = template
+                break
+        return found
+
+
+# some simple tests
+if __name__ == "__main__":
+    apt_pkg.init_config()
+    sources = SourcesList()
+
+    for entry in sources:
+        logging.info("entry %s" % entry.str())
+        #print entry.uri
+
+    mirror = is_mirror("http://archive.ubuntu.com/ubuntu/",
+                       "http://de.archive.ubuntu.com/ubuntu/")
+    logging.info("is_mirror(): %s" % mirror)
+
+    logging.info(is_mirror("http://archive.ubuntu.com/ubuntu",
+                    "http://de.archive.ubuntu.com/ubuntu/"))
+    logging.info(is_mirror("http://archive.ubuntu.com/ubuntu/",
+                    "http://de.archive.ubuntu.com/ubuntu"))

build/data/templates/Blankon.info

@@ -0,0 +1,370 @@
+ChangelogURI: http://arsip.blankonlinux.or.id/blankon/changelogs/pool/%s/%s/%s/%s_%s/changelog
+
+Suite: tambora
+RepositoryType: deb
+BaseURI: http://arsip.blankonlinux.or.id/blankon/
+MatchURI: arsip.blankonlinux.or.id/blankon
+MirrorsFile-amd64: /usr/share/python-apt/templates/Blankon.mirrors
+MirrorsFile-i386: /usr/share/python-apt/templates/Blankon.mirrors
+Description: Blankon 10.0 'Tambora'
+Component: main
+CompDescription: Officially supported
+CompDescriptionLong: Blankon-supported Free/Open Source software
+Component: extras
+CompDescription: Community-maintained
+CompDescriptionLong: Community-maintained Free/Open Source software
+Component: restricted
+CompDescription: Non-free drivers
+CompDescriptionLong: Proprietary drivers for devices
+Component: extras-restricted
+CompDescription: Restricted software
+CompDescriptionLong: Software restricted by copyright or legal issues
+
+Suite: tambora
+MatchName: .*
+BaseURI: cdrom:\[Blankon.*10.0
+MatchURI: cdrom:\[Blankon.*10.0
+Description: CDROM with Blankon 10.0 'Tambora'
+Available: False
+Component: main
+CompDescription: Officially supported
+Component: restricted
+CompDescription: Restricted copyright
+
+Suite: tambora-security
+ParentSuite: tambora
+RepositoryType: deb
+BaseURI: http://arsip.blankonlinux.or.id/blankon/
+MatchURI: arsip.blankonlinux.or.id/blankon
+Description: Important security updates
+
+Suite: tambora-updates
+ParentSuite: tambora
+RepositoryType: deb
+Description: Recommended updates
+
+Suite: suroboyo
+RepositoryType: deb
+BaseURI: http://arsip.blankonlinux.or.id/blankon/
+MatchURI: arsip.blankonlinux.or.id/blankon
+MirrorsFile-amd64: /usr/share/python-apt/templates/Blankon.mirrors
+MirrorsFile-i386: /usr/share/python-apt/templates/Blankon.mirrors
+Description: Blankon 9.0 'Suroboyo'
+Component: main
+CompDescription: Officially supported
+CompDescriptionLong: Blankon-supported Free/Open Source software
+Component: extras
+CompDescription: Community-maintained
+CompDescriptionLong: Community-maintained Free/Open Source software
+Component: restricted
+CompDescription: Non-free drivers
+CompDescriptionLong: Proprietary drivers for devices
+Component: extras-restricted
+CompDescription: Restricted software
+CompDescriptionLong: Software restricted by copyright or legal issues
+
+Suite: suroboyo
+MatchName: .*
+BaseURI: cdrom:\[Blankon.*9.0
+MatchURI: cdrom:\[Blankon.*9.0
+Description: CDROM with Blankon 9.0 'Suroboyo'
+Available: False
+Component: main
+CompDescription: Officially supported
+Component: restricted
+CompDescription: Restricted copyright
+
+Suite: suroboyo-security
+ParentSuite: suroboyo
+RepositoryType: deb
+BaseURI: http://arsip.blankonlinux.or.id/blankon/
+MatchURI: arsip.blankonlinux.or.id/blankon
+Description: Important security updates
+
+Suite: suroboyo-updates
+ParentSuite: suroboyo
+RepositoryType: deb
+Description: Recommended updates
+
+Suite: rote
+RepositoryType: deb
+BaseURI: http://arsip.blankonlinux.or.id/blankon/
+MatchURI: arsip.blankonlinux.or.id/blankon
+MirrorsFile-amd64: /usr/share/python-apt/templates/Blankon.mirrors
+MirrorsFile-i386: /usr/share/python-apt/templates/Blankon.mirrors
+Description: Blankon 8.0 'Rote'
+Component: main
+CompDescription: Officially supported
+CompDescriptionLong: Blankon-supported Free/Open Source software
+Component: extras
+CompDescription: Community-maintained
+CompDescriptionLong: Community-maintained Free/Open Source software
+Component: restricted
+CompDescription: Non-free drivers
+CompDescriptionLong: Proprietary drivers for devices
+Component: extras-restricted
+CompDescription: Restricted software
+CompDescriptionLong: Software restricted by copyright or legal issues
+
+Suite: rote
+MatchName: .*
+BaseURI: cdrom:\[Blankon.*8.0
+MatchURI: cdrom:\[Blankon.*8.0
+Description: CDROM with Blankon 8.0 'Rote'
+Available: False
+Component: main
+CompDescription: Officially supported
+Component: restricted
+CompDescription: Restricted copyright
+
+Suite: rote-security
+ParentSuite: rote
+RepositoryType: deb
+BaseURI: http://arsip.blankonlinux.or.id/blankon/
+MatchURI: arsip.blankonlinux.or.id/blankon
+Description: Important security updates
+
+Suite: rote-updates
+ParentSuite: rote
+RepositoryType: deb
+Description: Recommended updates
+
+Suite: pattimura
+RepositoryType: deb
+BaseURI: http://arsip.blankonlinux.or.id/blankon-legacy/
+MatchURI: arsip.blankonlinux.or.id/blankon-legacy
+MirrorsFile-amd64: /usr/share/python-apt/templates/Blankon.mirrors
+MirrorsFile-i386: /usr/share/python-apt/templates/Blankon.mirrors
+Description: Blankon 7.0 'Pattimura'
+Component: main
+CompDescription: Officially supported
+CompDescriptionLong: Blankon-supported Free/Open Source software
+Component: extras
+CompDescription: Community-maintained
+CompDescriptionLong: Community-maintained Free/Open Source software
+Component: restricted
+CompDescription: Non-free drivers
+CompDescriptionLong: Proprietary drivers for devices
+Component: extras-restricted
+CompDescription: Restricted software
+CompDescriptionLong: Software restricted by copyright or legal issues
+
+Suite: pattimura
+MatchName: .*
+BaseURI: cdrom:\[Blankon.*7.0
+MatchURI: cdrom:\[Blankon.*7.0
+Description: CDROM with Blankon 7.0 'Pattimura'
+Available: False
+Component: main
+CompDescription: Officially supported
+Component: restricted
+CompDescription: Restricted copyright
+
+Suite: pattimura-security
+ParentSuite: pattimura
+RepositoryType: deb
+BaseURI: http://arsip.blankonlinux.or.id/blankon-legacy/
+MatchURI: arsip.blankonlinux.or.id/blankon-legacy
+Description: Important security updates
+
+Suite: pattimura-updates
+ParentSuite: pattimura
+RepositoryType: deb
+Description: Recommended updates
+
+Suite: ombilin
+RepositoryType: deb
+BaseURI: http://arsip.blankonlinux.or.id/blankon-legacy/
+MatchURI: arsip.blankonlinux.or.id/blankon-legacy
+MirrorsFile-amd64: /usr/share/python-apt/templates/Blankon.mirrors
+MirrorsFile-i386: /usr/share/python-apt/templates/Blankon.mirrors
+Description: Blankon 6.0 'Ombilin'
+Component: main
+CompDescription: Officially supported
+CompDescriptionLong: Blankon-supported Free/Open Source software
+Component: extras
+CompDescription: Community-maintained
+CompDescriptionLong: Community-maintained Free/Open Source software
+Component: restricted
+CompDescription: Non-free drivers
+CompDescriptionLong: Proprietary drivers for devices
+Component: extras-restricted
+CompDescription: Restricted software
+CompDescriptionLong: Software restricted by copyright or legal issues
+
+Suite: ombilin
+MatchName: .*
+BaseURI: cdrom:\[Blankon.*6.0
+MatchURI: cdrom:\[Blankon.*6.0
+Description: CDROM with Blankon 6.0 'Ombilin'
+Available: False
+Component: main
+CompDescription: Officially supported
+Component: restricted
+CompDescription: Restricted copyright
+
+Suite: ombilin-security
+ParentSuite: ombilin
+RepositoryType: deb
+BaseURI: http://arsip.blankonlinux.or.id/blankon-legacy/
+MatchURI: arsip.blankonlinux.or.id/blankon-legacy
+Description: Important security updates
+
+Suite: ombilin-updates
+ParentSuite: ombilin
+RepositoryType: deb
+Description: Recommended updates
+
+Suite: nanggar
+RepositoryType: deb
+BaseURI: http://arsip.blankonlinux.or.id/blankon-legacy/
+MatchURI: arsip.blankonlinux.or.id/blankon-legacy
+MirrorsFile-amd64: /usr/share/python-apt/templates/Blankon.mirrors
+MirrorsFile-i386: /usr/share/python-apt/templates/Blankon.mirrors
+Description: Blankon 5.0 'Nanggar'
+Component: main
+CompDescription: Officially supported
+CompDescriptionLong: BlankOn-supported Open Source software
+Component: universe
+CompDescription: Community-maintained
+CompDescriptionLong: Community-maintained Open Source software
+Component: restricted
+CompDescription: Non-free drivers
+CompDescriptionLong: Proprietary drivers for devices
+Component: multiverse
+CompDescription: Restricted software
+CompDescriptionLong: Software restricted by copyright or legal issues
+
+Suite: nanggar
+MatchName: .*
+BaseURI: cdrom:\[Blankon.*5.0
+MatchURI: cdrom:\[Blankon.*5.0
+Description: Cdrom with Blankon 5.0 'Nanggar'
+Available: False
+Component: main
+CompDescription: Officially supported
+Component: restricted
+CompDescription: Restricted copyright
+
+Suite: nanggar-security
+ParentSuite: nanggar
+RepositoryType: deb
+BaseURI: http://arsip.blankonlinux.or.id/blankon-legacy/
+MatchURI: arsip.blankonlinux.or.id/blankon-legacy
+Description: Important security updates
+
+Suite: nanggar-updates
+ParentSuite: nanggar
+RepositoryType: deb
+Description: Recommended updates
+
+Suite: meuligoe
+RepositoryType: deb
+BaseURI: http://arsip.blankonlinux.or.id/blankon-legacy/
+MatchURI: arsip.blankonlinux.or.id/blankon-legacy
+MirrorsFile-amd64: /usr/share/python-apt/templates/Blankon.mirrors
+MirrorsFile-i386: /usr/share/python-apt/templates/Blankon.mirrors
+Description: Blankon 4.1 'Meuligoe'
+Component: main
+CompDescription: Officially supported
+CompDescriptionLong: BlankOn-supported Open Source software
+Component: restricted
+CompDescription: Non-free drivers
+CompDescriptionLong: Proprietary drivers for devices
+
+Suite: meuligoe
+MatchName: .*
+BaseURI: cdrom:\[Blankon.*4.1
+MatchURI: cdrom:\[Blankon.*4.1
+Description: Cdrom with Blankon 4.1 'Meuligoe'
+Available: False
+Component: main
+CompDescription: Officially supported
+Component: restricted
+CompDescription: Restricted copyright
+
+Suite: meuligoe-security
+ParentSuite: meuligoe
+RepositoryType: deb
+BaseURI: http://arsip.blankonlinux.or.id/blankon-legacy/
+MatchURI: arsip.blankonlinux.or.id/blankon-legacy
+Description: Important security updates
+
+Suite: meuligoe-updates
+ParentSuite: meuligoe
+RepositoryType: deb
+Description: Recommended updates
+
+Suite: lontara
+RepositoryType: deb
+BaseURI: http://arsip.blankonlinux.or.id/blankon-legacy/
+MatchURI: arsip.blankonlinux.or.id/blankon-legacy
+MirrorsFile-amd64: /usr/share/python-apt/templates/Blankon.mirrors
+MirrorsFile-i386: /usr/share/python-apt/templates/Blankon.mirrors
+Description: BlankOn 3.0 'Lontara'
+Component: main
+CompDescription: Officially supported
+CompDescriptionLong: BlankOn-supported Open Source software
+Component: restricted
+CompDescription: Non-free drivers
+CompDescriptionLong: Proprietary drivers for devices
+
+Suite: lontara
+MatchName: .*
+BaseURI: cdrom:\[Blankon.*3.0
+MatchURI: cdrom:\[Blankon.*3.0
+Description: Cdrom with Blankon 3.0 'Lontara'
+Available: False
+Component: main
+CompDescription: Officially supported
+Component: restricted
+CompDescription: Restricted copyright
+
+Suite: lontara-security
+ParentSuite: lontara
+RepositoryType: deb
+BaseURI: http://arsip.blankonlinux.or.id/blankon-legacy/
+MatchURI: arsip.blankonlinux.or.id/blankon-legacy
+Description: Important security updates
+
+Suite: lontara-updates
+ParentSuite: lontara
+RepositoryType: deb
+Description: Recommended updates
+
+Suite: konde
+RepositoryType: deb
+BaseURI: http://arsip.blankonlinux.or.id/blankon-legacy/
+MatchURI: arsip.blankonlinux.or.id/blankon-legacy
+MirrorsFile-amd64: /usr/share/python-apt/templates/Blankon.mirrors
+MirrorsFile-i386: /usr/share/python-apt/templates/Blankon.mirrors
+Description: Blankon 2.0 'Konde'
+Component: main
+CompDescription: Officially supported
+CompDescriptionLong: BlankOn-supported Open Source software
+Component: restricted
+CompDescription: Non-free drivers
+CompDescriptionLong: Proprietary drivers for devices
+
+Suite: konde
+MatchName: .*
+BaseURI: cdrom:\[Blankon.*2.0
+MatchURI: cdrom:\[Blankon.*2.0
+Description: Cdrom with Blankon 2.0 'Konde'
+Available: False
+Component: main
+CompDescription: Officially supported
+Component: restricted
+CompDescription: Restricted copyright
+
+Suite: konde-security
+ParentSuite: konde
+RepositoryType: deb
+BaseURI: http://arsip.blankonlinux.or.id/blankon-legacy/
+MatchURI: arsip.blankonlinux.or.id/blankon-legacy
+Description: Important security updates
+
+Suite: konde-updates
+ParentSuite: konde
+RepositoryType: deb
+Description: Recommended updates

build/data/templates/Blankon.mirrors

@@ -0,0 +1,17 @@
+#LOC:ID
+http://kambing.ui.ac.id/blankon/
+http://mirror.omadata.com/blankon/
+http://repo.ugm.ac.id/repo/blankon/
+http://buaya.klas.or.id/blankon/
+http://bos.fkip.uns.ac.id/blankon
+http://pandawa.ipb.ac.id/blankon/
+http://dl2.foss-id.web.id/blankon/
+http://shol.vlsm.org/blankon/
+http://openstorage.gunadarma.ac.id/blankon/
+http://debian.rab.co.id/blankon/
+http://singo.ub.ac.id/blankon/
+http://ftp.paudni.kemdiknas.go.id/blankon/
+http://blankon.idrepo.or.id/blankon/
+http://mirror.kioss.undip.ac.id/blankon/
+http://repo.unnes.ac.id/repo/blankon/
+http://kartolo.sby.datautama.net.id/blankon/

build/data/templates/Debian.info

@@ -0,0 +1,95 @@
+ChangelogURI: http://packages.debian.org/changelogs/pool/%s/%s/%s/%s_%s/changelog
+X-Exclude-Suites: buzz, rex, bo, hamm, slink, potato, woody, experimental
+
+Suite: {series}
+RepositoryType: deb
+BaseURI: http://deb.debian.org/debian/
+MatchURI: ((http|ftp)[0-9]*\.([a-z]*\.){{0,1}}|deb\.|httpredir\.)debian\.org
+MirrorsFile: Debian.mirrors
+Description: Debian {version} '{codename}'
+Component: main
+CompDescription: Officially supported
+Component: contrib
+CompDescription: DFSG-compatible Software with Non-Free Dependencies
+Component: non-free
+CompDescription: Non-DFSG-compatible Software
+
+Suite: {series}-security
+RepositoryType: deb
+BaseURI: http://security.debian.org/
+MatchURI: security\.debian\.org
+ParentSuite: {series}
+Description: Security updates
+X-Version: ge 11
+
+Suite: {series}/updates
+RepositoryType: deb
+BaseURI: http://security.debian.org/
+MatchURI: security\.debian\.org
+ParentSuite: {series}
+Description: Security updates
+X-Version: le 10
+
+Suite: {series}-updates
+RepositoryType: deb
+ParentSuite: {series}
+Description: Recommended updates
+X-Version: ge 7
+
+Suite: {series}-proposed-updates
+RepositoryType: deb
+ParentSuite: {series}
+Description: Proposed updates
+
+Suite: stable
+RepositoryType: deb
+BaseURI: http://http.us.debian.org/debian/
+MatchURI: ftp[0-9]*\.([a-z]*\.){0,1}debian\.org
+MirrorsFile: Debian.mirrors
+Description: Debian current stable release
+Component: main
+CompDescription: Officially supported
+Component: contrib
+CompDescription: DFSG-compatible Software with Non-Free Dependencies
+Component: non-free
+CompDescription: Non-DFSG-compatible Software
+
+Suite: testing
+RepositoryType: deb
+BaseURI: http://http.us.debian.org/debian/
+MatchURI: ftp[0-9]*\.([a-z]*\.){0,1}debian\.org
+MirrorsFile: Debian.mirrors
+Description: Debian testing
+Component: main
+CompDescription: Officially supported
+Component: contrib
+CompDescription: DFSG-compatible Software with Non-Free Dependencies
+Component: non-free
+CompDescription: Non-DFSG-compatible Software
+
+Suite: sid
+RepositoryType: deb
+BaseURI: http://http.us.debian.org/debian/
+MatchURI: ftp[0-9]*\.([a-z]*\.){0,1}debian\.org
+MirrorsFile: Debian.mirrors
+Description: Debian 'Sid' (unstable)
+Component: main
+CompDescription: Officially supported
+Component: contrib
+CompDescription: DFSG-compatible Software with Non-Free Dependencies
+Component: non-free
+CompDescription: Non-DFSG-compatible Software
+
+Suite: unstable
+RepositoryType: deb
+BaseURI: http://http.us.debian.org/debian/
+MatchURI: ftp[0-9]*\.([a-z]*\.){0,1}debian\.org
+MirrorsFile: Debian.mirrors
+Description: Debian 'Sid' (unstable)
+Component: main
+CompDescription: Officially supported
+Component: contrib
+CompDescription: DFSG-compatible Software with Non-Free Dependencies
+Component: non-free
+CompDescription: Non-DFSG-compatible Software
+

build/data/templates/Debian.mirrors

@@ -0,0 +1,371 @@
+#LOC:AM
+http://ftp.am.debian.org/debian/
+http://mirrors.asnet.am/debian/
+#LOC:AR
+http://debian.unnoba.edu.ar/debian/
+http://mirror.sitsa.com.ar/debian/
+#LOC:AT
+http://debian.anexia.at/debian/
+http://debian.lagis.at/debian/
+http://debian.mur.at/debian/
+http://debian.sil.at/debian/
+http://ftp.at.debian.org/debian/
+http://ftp.tu-graz.ac.at/mirror/debian/
+http://mirror.alwyzon.net/debian/
+#LOC:AU
+http://debian.mirror.digitalpacific.com.au/debian/
+http://debian.mirror.serversaustralia.com.au/debian/
+http://ftp.au.debian.org/debian/
+http://mirror.aarnet.edu.au/debian/
+http://mirror.amaze.com.au/debian/
+http://mirror.linux.org.au/debian/
+http://mirror.overthewire.com.au/debian/
+http://mirror.realcompute.io/debian/
+#LOC:BE
+http://ftp.be.debian.org/debian/
+http://ftp.belnet.be/debian/
+http://mirror.as35701.net/debian/
+#LOC:BG
+http://debian.ipacct.com/debian/
+http://debian.mnet.bg/debian/
+http://debian.telecoms.bg/debian/
+http://ftp.bg.debian.org/debian/
+http://ftp.uni-sofia.bg/debian/
+http://mirror.telepoint.bg/debian/
+http://mirrors.netix.net/debian/
+#LOC:BR
+http://alcateia.ufscar.br/debian/
+http://debian.c3sl.ufpr.br/debian/
+http://ftp.br.debian.org/debian/
+http://mirror.uepg.br/debian/
+#LOC:BY
+http://ftp.by.debian.org/debian/
+http://ftp.byfly.by/debian/
+http://mirror.datacenter.by/debian/
+#LOC:CA
+http://debian.mirror.iweb.ca/debian/
+http://mirror.csclub.uwaterloo.ca/debian/
+http://mirror.estone.ca/debian/
+http://mirror.it.ubc.ca/debian/
+#LOC:CH
+http://debian.ethz.ch/debian/
+http://ftp.ch.debian.org/debian/
+http://mirror.init7.net/debian/
+http://mirror.iway.ch/debian/
+http://mirror.sinavps.ch/debian/
+http://mirror1.infomaniak.com/debian/
+http://mirror2.infomaniak.com/debian/
+#LOC:CL
+http://debian.redlibre.cl/debian/
+http://ftp.cl.debian.org/debian/
+http://mirror.insacom.cl/debian/
+http://mirror.ufro.cl/debian/
+#LOC:CN
+http://mirror.bjtu.edu.cn/debian/
+http://mirror.nju.edu.cn/debian/
+http://mirror.sjtu.edu.cn/debian/
+http://mirrors.163.com/debian/
+http://mirrors.bfsu.edu.cn/debian/
+http://mirrors.hit.edu.cn/debian/
+http://mirrors.neusoft.edu.cn/debian/
+http://mirrors.tuna.tsinghua.edu.cn/debian/
+http://mirrors.ustc.edu.cn/debian/
+#LOC:CR
+http://debianmirror.una.ac.cr/debian/
+http://mirrors.ucr.ac.cr/debian/
+#LOC:CZ
+http://debian.mirror.web4u.cz/
+http://debian.superhosting.cz/debian/
+http://ftp.cvut.cz/debian/
+http://ftp.cz.debian.org/debian/
+http://ftp.debian.cz/debian/
+http://ftp.sh.cvut.cz/debian/
+http://ftp.zcu.cz/debian/
+http://merlin.fit.vutbr.cz/debian/
+http://mirror.dkm.cz/debian/
+http://mirror.it4i.cz/debian/
+http://mirrors.nic.cz/debian/
+#LOC:DE
+http://artfiles.org/debian/
+http://de.mirrors.clouvider.net/debian/
+http://debian.charite.de/debian/
+http://debian.inf.tu-dresden.de/debian/
+http://debian.intergenia.de/debian/
+http://debian.mirror.iphh.net/debian/
+http://debian.mirror.lrz.de/debian/
+http://debian.netcologne.de/debian/
+http://debian.tu-bs.de/debian/
+http://ftp-stud.hs-esslingen.de/debian/
+http://ftp.de.debian.org/debian/
+http://ftp.fau.de/debian/
+http://ftp.gwdg.de/debian/
+http://ftp.hosteurope.de/mirror/ftp.debian.org/debian/
+http://ftp.plusline.net/debian/
+http://ftp.tu-chemnitz.de/debian/
+http://ftp.tu-clausthal.de/debian/
+http://ftp.uni-bayreuth.de/debian/
+http://ftp.uni-hannover.de/debian/debian/
+http://ftp.uni-kl.de/debian/
+http://ftp.uni-mainz.de/debian/
+http://ftp.wrz.de/debian/
+http://mirror.23m.com/debian/
+http://mirror.de.leaseweb.net/debian/
+http://mirror.dogado.de/debian/
+http://mirror.ipb.de/debian/
+http://mirror.netzwerge.de/debian/
+http://mirror.united-gameserver.de/debian/
+http://mirror.wtnet.de/debian/
+http://mirrors.xtom.de/debian/
+http://packages.hs-regensburg.de/debian/
+http://pubmirror.plutex.de/debian/
+#LOC:DK
+http://ftp.dk.debian.org/debian/
+http://mirror.asergo.com/debian/
+http://mirror.one.com/debian/
+http://mirrors.dotsrc.org/debian/
+http://mirrors.rackhosting.com/debian/
+#LOC:EE
+http://mirrors.xtom.ee/debian/
+#LOC:ES
+http://debian.grn.cat/debian/
+http://debian.redimadrid.es/debian/
+http://debian.redparra.com/debian/
+http://debian.uvigo.es/debian/
+http://ftp.caliu.cat/debian/
+http://ftp.cica.es/debian/
+http://ftp.es.debian.org/debian/
+http://ftp.udc.es/debian/
+http://mirror.librelabucm.org/debian/
+http://repo.ifca.es/debian/
+http://softlibre.unizar.es/debian/
+http://ulises.hostalia.com/debian/
+#LOC:FI
+http://ftp.fi.debian.org/debian/
+http://www.nic.funet.fi/debian/
+#LOC:FR
+http://apt.tetaneutral.net/debian/
+http://deb-mir1.naitways.net/debian/
+http://debian.apt-mirror.de/debian/
+http://debian.obspm.fr/debian/
+http://debian.polytech-lille.fr/debian/
+http://debian.proxad.net/debian/
+http://debian.univ-tlse2.fr/debian/
+http://ftp.ec-m.fr/debian/
+http://ftp.fr.debian.org/debian/
+http://ftp.lip6.fr/pub/linux/distributions/debian/
+http://ftp.rezopole.net/debian/
+http://ftp.u-picardie.fr/debian/
+http://ftp.u-strasbg.fr/debian/
+http://ftp.univ-pau.fr/linux/mirrors/debian/
+http://miroir.univ-lorraine.fr/debian/
+http://mirror.johnnybegood.fr/debian/
+http://mirror.plusserver.com/debian/debian/
+http://mirrors.ircam.fr/pub/debian/
+#LOC:GB
+http://debian.mirror.uk.sargasso.net/debian/
+http://debian.mirrors.uk2.net/debian/
+http://free.hands.com/debian/
+http://ftp.ticklers.org/debian/
+http://ftp.uk.debian.org/debian/
+http://mirror.cov.ukservers.com/debian/
+http://mirror.lchost.net/debian/
+http://mirror.mythic-beasts.com/debian/
+http://mirror.ox.ac.uk/debian/
+http://mirror.positive-internet.com/debian/
+http://mirror.sov.uk.goscomb.net/debian/
+http://mirrors.coreix.net/debian/
+http://mirrorservice.org/sites/ftp.debian.org/debian/
+http://uk.mirrors.clouvider.net/debian/
+http://ukdebian.mirror.anlx.net/debian/
+#LOC:GE
+http://debian.grena.ge/debian/
+#LOC:GR
+http://debian.otenet.gr/debian/
+#LOC:HK
+http://ftp.hk.debian.org/debian/
+http://mirror.xtom.com.hk/debian/
+#LOC:HR
+http://debian.carnet.hr/debian/
+http://debian.iskon.hr/debian/
+http://ftp.hr.debian.org/debian/
+#LOC:HU
+http://ftp.bme.hu/debian/
+http://ftp.fsn.hu/debian/
+http://ftp.hu.debian.org/debian/
+http://repo.jztkft.hu/debian/
+#LOC:ID
+http://kartolo.sby.datautama.net.id/debian/
+http://kebo.pens.ac.id/debian/
+http://mirror.unair.ac.id/debian/
+http://mr.heru.id/debian/
+#LOC:IL
+http://debian.interhost.co.il/debian/
+#LOC:IN
+http://mirror.cse.iitk.ac.in/debian/
+#LOC:IR
+http://archive.debian.petiak.ir/debian/
+http://debian.asis.ai/debian/
+http://debian.hostiran.ir/debian/
+http://debian.parspack.com/debian/
+http://mirror.aminidc.com/debian/
+http://mirrors.pardisco.co/debian/
+#LOC:IS
+http://ftp.is.debian.org/debian/
+#LOC:IT
+http://debian.connesi.it/debian/
+http://debian.mirror.garr.it/debian/
+http://ftp.it.debian.org/debian/
+http://ftp.linux.it/debian/
+http://giano.com.dist.unige.it/debian/
+http://mirror.units.it/debian/
+#LOC:JP
+http://debian-mirror.sakura.ne.jp/debian/
+http://ftp.jp.debian.org/debian/
+http://ftp.riken.jp/Linux/debian/debian/
+http://mirrors.xtom.jp/debian/
+#LOC:KE
+http://debian.mirror.ac.ke/debian/
+http://debian.mirror.liquidtelecom.com/debian/
+#LOC:KR
+http://ftp.kaist.ac.kr/debian/
+http://ftp.kr.debian.org/debian/
+http://ftp.lanet.kr/debian/
+http://mirror.anigil.com/debian/
+#LOC:KZ
+http://mirror.hoster.kz/debian/
+http://mirror.ps.kz/debian/
+#LOC:LT
+http://debian.balt.net/debian/
+http://debian.mirror.vu.lt/debian/
+http://ftp.lt.debian.org/debian/
+http://mirror.litnet.lt/debian/
+http://mirror.vpsnet.com/debian/
+#LOC:LU
+http://debian.mirror.root.lu/debian/
+#LOC:LV
+http://debian.koyanet.lv/debian/
+http://mirror.cloudhosting.lv/debian/
+#LOC:MD
+http://ftp.md.debian.org/debian/
+http://mirror.as43289.net/debian/
+http://mirrors.mivocloud.com/debian/
+#LOC:MK
+http://mirror.onevip.mk/debian/
+#LOC:NC
+http://mirror.lagoon.nc/debian/
+#LOC:NL
+http://debian.mirror.cambrium.nl/debian/
+http://debian.snt.utwente.nl/debian/
+http://ftp.nl.debian.org/debian/
+http://mirror.duocast.net/debian/
+http://mirror.i3d.net/debian/
+http://mirror.nforce.com/debian/
+http://mirror.nl.datapacket.com/debian/
+http://mirror.nl.leaseweb.net/debian/
+http://mirror.seedvps.com/debian/
+http://mirrors.xtom.nl/debian/
+http://nl.mirrors.clouvider.net/debian/
+#LOC:NO
+http://ftp.no.debian.org/debian/
+http://ftp.uio.no/debian/
+#LOC:NZ
+http://ftp.nz.debian.org/debian/
+http://mirror.fsmg.org.nz/debian/
+#LOC:PL
+http://debian.inhost.pro/debian/
+http://ftp.agh.edu.pl/debian/
+http://ftp.icm.edu.pl/pub/Linux/debian/
+http://ftp.pl.debian.org/debian/
+http://ftp.psnc.pl/debian/
+http://ftp.task.gda.pl/debian/
+#LOC:PT
+http://ftp.eq.uc.pt/software/Linux/debian/
+http://ftp.rnl.tecnico.ulisboa.pt/pub/debian/
+http://mirrors.ptisp.pt/debian/
+http://mirrors.up.pt/debian/
+#LOC:RE
+http://debian.mithril.re/debian/
+http://depot-debian.univ-reunion.fr/debian/
+#LOC:RO
+http://mirror.linux.ro/debian/
+http://mirrors.hostico.ro/debian/
+http://mirrors.nav.ro/debian/
+http://mirrors.nxthost.com/debian/
+#LOC:RS
+http://mirror.pmf.kg.ac.rs/debian/
+#LOC:RU
+http://ftp.psn.ru/debian/
+http://ftp.ru.debian.org/debian/
+http://mirror.corbina.net/debian/
+http://mirror.docker.ru/debian/
+http://mirror.mephi.ru/debian/
+http://mirror.surf/debian/
+http://mirror.truenetwork.ru/debian/
+http://mirrors.powernet.com.ru/debian/
+#LOC:SE
+http://debian.lth.se/debian/
+http://debian.mirror.su.se/debian/
+http://ftp.acc.umu.se/debian/
+http://ftp.se.debian.org/debian/
+http://ftpmirror1.infania.net/debian/
+http://mirror.zetup.net/debian/
+http://mirrors.glesys.net/debian/
+#LOC:SG
+http://mirror.coganng.com/debian/
+http://mirror.sg.gs/debian/
+#LOC:SI
+http://ftp.si.debian.org/debian/
+#LOC:SK
+http://ftp.antik.sk/debian/
+http://ftp.debian.sk/debian/
+http://ftp.sk.debian.org/debian/
+#LOC:TH
+http://ftp.debianclub.org/debian/
+http://mirror.applebred.net/debian/
+http://mirror.kku.ac.th/debian/
+#LOC:TR
+http://debian.gnu.gen.tr/debian/
+http://ftp.linux.org.tr/debian/
+http://ftp.tr.debian.org/debian/
+#LOC:TW
+http://debian.cs.nycu.edu.tw/debian/
+http://debian.csie.ncku.edu.tw/debian/
+http://debian.csie.ntu.edu.tw/debian/
+http://ftp.tw.debian.org/debian/
+http://opensource.nchc.org.tw/debian/
+http://tw1.mirror.blendbyte.net/debian/
+#LOC:UA
+http://debian.astra.in.ua/debian/
+http://debian.netforce.hosting/debian/
+http://debian.volia.net/debian/
+http://fastmirror.pp.ua/debian/
+http://mirror.mirohost.net/debian/
+#LOC:US
+http://atl.mirrors.clouvider.net/debian/
+http://debian-archive.trafficmanager.net/debian/
+http://debian.cs.binghamton.edu/debian/
+http://debian.osuosl.org/debian/
+http://ftp.us.debian.org/debian/
+http://la.mirrors.clouvider.net/debian/
+http://mirror.clarkson.edu/debian/
+http://mirror.cogentco.com/debian/
+http://mirror.dal.nexril.net/debian/
+http://mirror.keystealth.org/debian/
+http://mirror.siena.edu/debian/
+http://mirror.steadfast.net/debian/
+http://mirror.us.leaseweb.net/debian/
+http://mirror.us.oneandone.net/debian/
+http://mirrors.accretive-networks.net/debian/
+http://mirrors.lug.mtu.edu/debian/
+http://mirrors.namecheap.com/debian/
+http://mirrors.ocf.berkeley.edu/debian/
+http://mirrors.vcea.wsu.edu/debian/
+http://mirrors.wikimedia.org/debian/
+http://nyc.mirrors.clouvider.net/debian/
+#LOC:VN
+http://debian.xtdv.net/debian/
+http://mirror.bizflycloud.vn/debian/
+http://mirrors.bkns.vn/debian/
+#LOC:ZA
+http://debian.saix.net/
+http://ftp.is.co.za/debian/

build/data/templates/Kali.info

@@ -0,0 +1,32 @@
+ChangelogURI: http://pkg.kali.org/media/packages/%s/%s/%s/%s/changelog-%s
+
+Suite: kali-rolling
+RepositoryType: deb
+BaseURI: http://http.kali.org/kali/
+MatchURI: (kali\.download|(archive.*|http)\.kali\.org)
+MirrorsFile: Kali.mirrors
+Description: Kali Rolling
+Component: main
+CompDescription: Officially supported
+Component: contrib
+CompDescription: DFSG-compatible Software with Non-Free Dependencies
+Component: non-free
+CompDescription: Non-DFSG-compatible Software
+
+Suite: kali-dev
+RepositoryType: deb
+BaseURI: http://http.kali.org/kali/
+MatchURI: (kali\.download|(archive.*|http)\.kali\.org)
+MirrorsFile: Kali.mirrors
+Description: Kali Development Release
+Component: main
+CompDescription: Officially supported
+Component: contrib
+CompDescription: DFSG-compatible Software with Non-Free Dependencies
+Component: non-free
+CompDescription: Non-DFSG-compatible Software
+
+Suite: kali-experimental
+RepositoryType: deb
+ParentSuite: kali-dev
+Description: Kali Experimental Release

build/data/templates/Kali.mirrors

@@ -0,0 +1,2 @@
+http://http.kali.org/kali/
+http://kali.download/kali/

build/data/templates/Tanglu.info

@@ -0,0 +1,42 @@
+ChangelogURI: http://changelogs.tanglu.org/changelogs/%s/%s/%s/%s_%s/changelog
+
+Suite: aequorea
+RepositoryType: deb
+BaseURI: http://archive.tanglu.org/tanglu/
+MatchURI: archive.tanglu.org/tanglu
+MirrorsFile: Tanglu.mirrors
+Description: Tanglu 1.0 'Aequorea'
+Component: main
+CompDescription: Officially supported
+Component: contrib
+CompDescription: DFSG-compatible Software with Non-Free Dependencies
+Component: non-free
+CompDescription: Non-DFSG-compatible Software
+
+Suite: aequorea-updates
+RepositoryType: deb
+ParentSuite: aequorea
+Description: Recommended updates
+
+Suite: bartholomea
+RepositoryType: deb
+BaseURI: http://archive.tanglu.org/tanglu/
+MatchURI: archive.tanglu.org/tanglu
+MirrorsFile: Tanglu.mirrors
+Description: Tanglu 2.0 'Bartholomea'
+Component: main
+CompDescription: Officially supported
+Component: contrib
+CompDescription: DFSG-compatible Software with Non-Free Dependencies
+Component: non-free
+CompDescription: Non-DFSG-compatible Software
+
+Suite: bartholomea-security
+RepositoryType: deb
+ParentSuite: bartholomea
+Description: Security updates
+
+Suite: bartholomea-updates
+RepositoryType: deb
+ParentSuite: bartholomea
+Description: Recommended updates

build/data/templates/Tanglu.mirrors

@@ -0,0 +1,3 @@
+#LOC:DE
+http://de.archive.tanglu.org/tanglu/
+http://mirror1.hs-esslingen.de/pub/Mirrors/archive.tanglu.org/tanglu/

build/data/templates/Ubuntu.info

@@ -0,0 +1,223 @@
+ChangelogURI: http://changelogs.ubuntu.com/changelogs/pool/%s/%s/%s/%s_%s/changelog
+
+Suite: devel
+RepositoryType: deb
+BaseURI: http://ports.ubuntu.com/ubuntu-ports/
+MatchURI: ports.ubuntu.com/ubuntu-ports
+BaseURI-amd64: http://archive.ubuntu.com/ubuntu
+MatchURI-amd64: archive.ubuntu.com/ubuntu
+BaseURI-i386: http://archive.ubuntu.com/ubuntu
+MatchURI-i386: archive.ubuntu.com/ubuntu
+MirrorsFile-amd64: Ubuntu.mirrors
+MirrorsFile-i386: Ubuntu.mirrors
+Description: Ubuntu development series
+Component: main
+CompDescription: Officially supported
+CompDescriptionLong: Canonical-supported free and open-source software
+Component: universe
+CompDescription: Community-maintained
+CompDescriptionLong: Community-maintained free and open-source software
+Component: restricted
+CompDescription: Non-free drivers
+CompDescriptionLong: Proprietary drivers for devices
+Component: multiverse
+ParentComponent: universe
+CompDescription: Restricted software
+CompDescriptionLong: Software restricted by copyright or legal issues
+
+Suite: devel
+ParentSuite: devel
+RepositoryType: deb-src
+BaseURI: http://archive.ubuntu.com/ubuntu/
+MatchURI: archive.ubuntu.com/ubuntu|ports.ubuntu.com/ubuntu-ports
+Description: Ubuntu development series
+
+Suite: devel
+Official: false
+RepositoryType: deb
+BaseURI: http://extras.ubuntu.com
+MatchURI: extras.ubuntu.com
+Description: Independent
+Component: main
+CompDescription: Provided by third-party software developers
+CompDescriptionLong: Software offered by third party developers.
+
+Suite: devel-security
+ParentSuite: devel
+RepositoryType: deb
+BaseURI: http://ports.ubuntu.com/ubuntu-ports/
+MatchURI: ports.ubuntu.com/ubuntu-ports
+BaseURI-amd64: http://security.ubuntu.com/ubuntu/
+MatchURI-amd64: archive.ubuntu.com/ubuntu|security.ubuntu.com
+BaseURI-i386: http://security.ubuntu.com/ubuntu/
+MatchURI-i386: archive.ubuntu.com/ubuntu|security.ubuntu.com
+Description: Important security updates
+
+Suite: devel-security
+ParentSuite: devel
+RepositoryType: deb-src
+BaseURI: http://archive.ubuntu.com/ubuntu/
+MatchURI: archive.ubuntu.com/ubuntu|ports.ubuntu.com/ubuntu-ports|security.ubuntu.com
+Description: Important security updates
+
+Suite: devel-updates
+ParentSuite: devel
+RepositoryType: deb
+Description: Recommended updates
+
+Suite: devel-updates
+ParentSuite: devel
+RepositoryType: deb-src
+BaseURI: http://archive.ubuntu.com/ubuntu/
+MatchURI: archive.ubuntu.com/ubuntu|ports.ubuntu.com/ubuntu-ports
+Description: Recommended updates
+
+Suite: devel-proposed
+ParentSuite: devel
+RepositoryType: deb
+Description: Pre-released updates
+
+Suite: devel-proposed
+ParentSuite: devel
+RepositoryType: deb-src
+BaseURI: http://archive.ubuntu.com/ubuntu/
+MatchURI: archive.ubuntu.com/ubuntu|ports.ubuntu.com/ubuntu-ports
+Description: Pre-released updates
+
+Suite: devel-backports
+ParentSuite: devel
+RepositoryType: deb
+Description: Unsupported updates
+
+Suite: devel-backports
+ParentSuite: devel
+RepositoryType: deb-src
+BaseURI: http://archive.ubuntu.com/ubuntu/
+MatchURI: archive.ubuntu.com/ubuntu|ports.ubuntu.com/ubuntu-ports
+Description: Unsupported updates
+
+Suite: {series}
+RepositoryType: deb
+BaseURI: http://ports.ubuntu.com/ubuntu-ports/
+MatchURI: ports.ubuntu.com/ubuntu-ports
+BaseURI-amd64: http://archive.ubuntu.com/ubuntu
+MatchURI-amd64: archive.ubuntu.com/ubuntu
+BaseURI-i386: http://archive.ubuntu.com/ubuntu
+MatchURI-i386: archive.ubuntu.com/ubuntu
+MirrorsFile-amd64: Ubuntu.mirrors
+MirrorsFile-i386: Ubuntu.mirrors
+Description: Ubuntu {version} '{codename}'
+Component: main
+CompDescription: Officially supported
+CompDescriptionLong: Canonical-supported free and open-source software
+Component: universe
+CompDescription: Community-maintained
+CompDescriptionLong: Community-maintained free and open-source software
+Component: restricted
+CompDescription: Non-free drivers
+CompDescriptionLong: Proprietary drivers for devices
+Component: multiverse
+ParentComponent: universe
+CompDescription: Restricted software
+CompDescriptionLong: Software restricted by copyright or legal issues
+
+Suite: {series}
+ParentSuite: {series}
+RepositoryType: deb-src
+BaseURI: http://archive.ubuntu.com/ubuntu/
+MatchURI: archive.ubuntu.com/ubuntu|ports.ubuntu.com/ubuntu-ports
+Description: Ubuntu {version} '{codename}'
+X-Version: ge 11.04
+
+Suite: {series}
+RepositoryType: deb
+MatchName: .*
+BaseURI: cdrom:\[Ubuntu.*{version}
+MatchURI: cdrom:\[Ubuntu.*{version}
+Description: Installation medium with Ubuntu {version} '{codename}'
+Available: False
+Component: main
+CompDescription: Officially supported
+Component: restricted
+CompDescription: Restricted copyright
+
+Suite: {series}
+Official: false
+RepositoryType: deb
+BaseURI: http://archive.canonical.com
+MatchURI: archive.canonical.com
+Description: Canonical Partners
+Component: partner
+CompDescription: Software packaged by Canonical for their partners
+CompDescriptionLong: This software is not part of Ubuntu.
+X-Version: le 20.04, ge 10.10
+
+Suite: {series} 
+Official: false
+RepositoryType: deb
+BaseURI: http://extras.ubuntu.com
+MatchURI: extras.ubuntu.com
+Description: Independent
+Component: main
+CompDescription: Provided by third-party software developers
+CompDescriptionLong: Software offered by third party developers.
+X-Version: le 15.04, ge 10.10
+
+Suite: {series}-security
+ParentSuite: {series}
+RepositoryType: deb
+BaseURI: http://ports.ubuntu.com/ubuntu-ports/
+MatchURI: ports.ubuntu.com/ubuntu-ports
+BaseURI-amd64: http://security.ubuntu.com/ubuntu/
+MatchURI-amd64: archive.ubuntu.com/ubuntu|security.ubuntu.com
+BaseURI-i386: http://security.ubuntu.com/ubuntu/
+MatchURI-i386: archive.ubuntu.com/ubuntu|security.ubuntu.com
+Description: Important security updates
+
+Suite: {series}-security
+ParentSuite: {series}
+RepositoryType: deb-src
+BaseURI: http://archive.ubuntu.com/ubuntu/
+MatchURI: archive.ubuntu.com/ubuntu|ports.ubuntu.com/ubuntu-ports|security.ubuntu.com
+Description: Important security updates
+X-Version: ge 11.04
+
+Suite: {series}-updates
+ParentSuite: {series}
+RepositoryType: deb
+Description: Recommended updates
+
+Suite: {series}-updates
+ParentSuite: {series}
+RepositoryType: deb-src
+BaseURI: http://archive.ubuntu.com/ubuntu/
+MatchURI: archive.ubuntu.com/ubuntu|ports.ubuntu.com/ubuntu-ports
+Description: Recommended updates
+X-Version: ge 11.04
+
+Suite: {series}-proposed
+ParentSuite: {series}
+RepositoryType: deb
+Description: Pre-released updates
+
+Suite: {series}-proposed
+ParentSuite: {series}
+RepositoryType: deb-src
+BaseURI: http://archive.ubuntu.com/ubuntu/
+MatchURI: archive.ubuntu.com/ubuntu|ports.ubuntu.com/ubuntu-ports
+Description: Pre-released updates
+X-Version: ge 11.04
+
+Suite: {series}-backports
+ParentSuite: {series}
+RepositoryType: deb
+Description: Unsupported updates
+
+Suite: {series}-backports
+ParentSuite: {series}
+RepositoryType: deb-src
+BaseURI: http://archive.ubuntu.com/ubuntu/
+MatchURI: archive.ubuntu.com/ubuntu|ports.ubuntu.com/ubuntu-ports
+Description: Unsupported updates
+X-Version: ge 11.04
+

build/data/templates/Ubuntu.mirrors

@@ -0,0 +1,659 @@
+mirror://mirrors.ubuntu.com/mirrors.txt
+#LOC:AM
+http://mirrors.asnet.am/ubuntu/
+http://ubuntu.mirror.gnc.am/ubuntu/
+#LOC:AR
+http://mirrors.eze.sysarmy.com/ubuntu/
+http://ubuntu.unc.edu.ar/ubuntu/
+https://mirror.sitsa.com.ar/ubuntu/
+https://mirrors.dc.clear.net.ar/ubuntu/
+https://ubuntu.zero.com.ar/ubuntu/
+#LOC:AT
+http://mirror.easyname.at/ubuntu-archive/
+http://ubuntu.anexia.at/ubuntu/
+http://ubuntu.lagis.at/ubuntu/
+http://ubuntu.uni-klu.ac.at/ubuntu/
+https://mirror.alwyzon.net/ubuntu/
+#LOC:AU
+http://ftp.iinet.net.au/pub/ubuntu/
+http://mirror.aarnet.edu.au/pub/ubuntu/archive/
+http://mirror.internode.on.net/pub/ubuntu/ubuntu/
+http://mirror.netspace.net.au/pub/ubuntu/
+http://mirror.overthewire.com.au/ubuntu/
+https://mirror.datamossa.io/ubuntu/archive/
+https://mirror.internet.asn.au/pub/ubuntu/archive/
+https://mirror.realcompute.io/ubuntu/
+https://ubuntu.mirror.digitalpacific.com.au/archive/
+https://ubuntu.mirror.serversaustralia.com.au/ubuntu/
+#LOC:AZ
+http://aze.archive.ubuntu.com/ubuntu/
+https://mirror.hostart.az/Ubuntu/
+https://mirror.yer.az/ubuntu/archive/
+#LOC:BA
+http://archive.ubuntu.mirror.ba/ubuntu/
+#LOC:BD
+http://mirror.dhakacom.com/ubuntu-archive/
+http://mirror.xeonbd.com/ubuntu-archive/
+https://mirror.limda.net/Ubuntu/
+#LOC:BE
+http://ftp.belnet.be/ubuntu/
+http://mirror.unix-solutions.be/ubuntu/
+https://mirrors-ubuntu.behostings.com/ubuntu/
+#LOC:BG
+http://mirror.bg.host.ag/ubuntu/
+http://mirrors.neterra.net/ubuntu/
+http://ubuntu.ipacct.com/ubuntu/
+https://mirror.telepoint.bg/ubuntu/
+https://mirrors.storpool.com/ubuntu/archive/
+#LOC:BR
+http://mirror.ufam.edu.br/ubuntu/
+http://mirror.ufscar.br/ubuntu/
+http://mirror.unesp.br/ubuntu/
+http://sft.if.usp.br/ubuntu/
+http://ubuntu-archive.locaweb.com.br/ubuntu/
+http://ubuntu.c3sl.ufpr.br/ubuntu/
+http://ubuntu.mti.mt.gov.br/
+https://mirror.uepg.br/ubuntu/
+https://ubuntu.itsbrasil.net/ubuntu/
+https://ubuntu.letscloud.io/ubuntu/
+#LOC:BY
+http://ftp.byfly.by/ubuntu/
+http://mirror.datacenter.by/ubuntu/
+#LOC:CA
+ftp://ftp.cs.mun.ca/pub/mirror/ubuntu/
+http://archive.ubuntu.mirror.rafal.ca/ubuntu/
+http://gpl.savoirfairelinux.net/pub/mirrors/ubuntu/
+http://mirror.ca-tr.kamatera.com/ubuntu/
+http://mirror.its.dal.ca/ubuntu/
+http://mirror.rcg.sfu.ca/mirror/ubuntu/
+http://mirrors.layeronline.com/ubuntu/
+http://ubuntu.bhs.mirrors.ovh.net/ubuntu/
+http://ubuntu.mirror.globo.tech/
+http://ubuntu.mirror.iweb.ca/
+http://ubuntu.mirror.rafal.ca/ubuntu/
+https://mirror.0xem.ma/ubuntu/
+https://mirror.csclub.uwaterloo.ca/ubuntu/
+https://mirror.hep.gg/ubuntu/
+https://mirror.it.ubc.ca/ubuntu/
+https://mirror.reenigne.net/ubuntu/
+https://mirror01-pcl-ott1.accuris.ca/ubuntu/
+https://mirrors.switch.ca/ubuntu/
+https://muug.ca/mirror/ubuntu/
+#LOC:CD
+https://mirrors.united.cd/ubuntu/
+#LOC:CH
+http://archive.ubuntu.csg.uzh.ch/ubuntu/
+http://mirror.infomaniak.ch/ubuntu/
+http://pkg.adfinis.com/ubuntu/
+http://ubuntu.ethz.ch/ubuntu/
+https://mirror.init7.net/ubuntu/
+https://mirror.solnet.ch/ubuntu/
+#LOC:CL
+http://mirror.uchile.cl/ubuntu/
+https://mirror.hnd.cl/ubuntu/
+https://mirror.ufro.cl/ubuntu/
+#LOC:CN
+http://ftp.sjtu.edu.cn/ubuntu/
+http://mirror.lzu.edu.cn/ubuntu/
+http://mirrors.aliyun.com/ubuntu/
+http://mirrors.cn99.com/ubuntu/
+http://mirrors.cqu.edu.cn/ubuntu/
+http://mirrors.huaweicloud.com/repository/ubuntu/
+http://mirrors.sohu.com/ubuntu/
+http://mirrors.yun-idc.com/ubuntu/
+https://mirror.bjtu.edu.cn/ubuntu/
+https://mirror.nju.edu.cn/ubuntu/
+https://mirror.nyist.edu.cn/ubuntu/
+https://mirrors.bfsu.edu.cn/ubuntu/
+https://mirrors.bupt.edu.cn/ubuntu/
+https://mirrors.cloud.tencent.com/ubuntu/
+https://mirrors.cnnic.cn/ubuntu/
+https://mirrors.hit.edu.cn/ubuntu/
+https://mirrors.jlu.edu.cn/ubuntu/
+https://mirrors.sdu.edu.cn/ubuntu/
+https://mirrors.tuna.tsinghua.edu.cn/ubuntu-ports/
+https://mirrors.tuna.tsinghua.edu.cn/ubuntu/
+https://mirrors.ustc.edu.cn/ubuntu/
+https://mirrors.xjtu.edu.cn/ubuntu/
+https://mirrors.zju.edu.cn/ubuntu/
+https://repo.huaweicloud.com/ubuntu/
+#LOC:CO
+http://mirror.unimagdalena.edu.co/ubuntu/
+https://edgeuno-bog2.mm.fcix.net/ubuntu/
+#LOC:CR
+http://ubuntu.ucr.ac.cr/ubuntu/
+#LOC:CY
+http://mirror.library.ucy.ac.cy/linux/ubuntu/archive/
+#LOC:CZ
+http://ftp.cvut.cz/ubuntu/
+http://ftp.linux.cz/pub/linux/ubuntu/
+http://ucho.ignum.cz/ubuntu/
+https://cz.archive.ubuntu.com/ubuntu/
+https://ftp.sh.cvut.cz/ubuntu/
+https://mirror.dkm.cz/ubuntu/
+https://mirror.it4i.cz/ubuntu/
+#LOC:DE
+ftp://ftp.fu-berlin.de/linux/ubuntu/
+http://artfiles.org/ubuntu.com/
+http://ftp-stud.hs-esslingen.de/ubuntu/
+http://ftp.fau.de/ubuntu/
+http://ftp.halifax.rwth-aachen.de/ubuntu/
+http://ftp.hosteurope.de/mirror/archive.ubuntu.com/
+http://ftp.rz.tu-bs.de/pub/mirror/ubuntu-packages/
+http://ftp.stw-bonn.de/ubuntu/
+http://ftp.tu-chemnitz.de/pub/linux/ubuntu-ports/
+http://ftp.tu-chemnitz.de/pub/linux/ubuntu/
+http://ftp.tu-ilmenau.de/mirror/ubuntu/
+http://ftp.uni-bayreuth.de/linux/ubuntu/ubuntu/
+http://ftp.uni-kl.de/pub/linux/ubuntu/
+http://ftp.uni-mainz.de/ubuntu/
+http://ftp5.gwdg.de/pub/linux/debian/ubuntu/
+http://mirror.daniel-jost.net/ubuntu/
+http://mirror.eu-fr.kamatera.com/ubuntu/
+http://mirror.funkfreundelandshut.de/ubuntu/
+http://mirror.ipb.de/ubuntu/
+http://mirror.kamp.de/ubuntu/
+http://mirror.serverloft.eu/ubuntu/ubuntu/
+http://mirror.wtnet.de/ubuntu/
+http://mirror2.tuxinator.org/ubuntu/
+http://packages.oth-regensburg.de/ubuntu/
+http://suse.uni-leipzig.de/pub/releases.ubuntu.com/ubuntu/
+http://ubuntu.mirror.lrz.de/ubuntu/
+http://ubuntu.mirror.tudos.de/ubuntu/
+https://de.mirrors.clouvider.net/ubuntu/
+https://debian.charite.de/ubuntu/
+https://ftp.uni-stuttgart.de/ubuntu/
+https://mirror.23m.com/ubuntu/
+https://mirror.creoline.net/ubuntu/
+https://mirror.cxserv.de/ubuntu/
+https://mirror.de.leaseweb.net/ubuntu/
+https://mirror.dogado.de/ubuntu/
+https://mirror.kkg.berlin/ubuntu/
+https://mirror.netcologne.de/ubuntu/
+https://mirror.netzwerge.de/ubuntu/
+https://mirror.scaleuptech.com/ubuntu/
+https://mirror.united-gameserver.de/ubuntu/
+https://mirrors.xtom.de/ubuntu/
+#LOC:DK
+http://ftp.klid.dk/ftp/ubuntu/
+http://mirror.one.com/ubuntu/
+http://mirrors.dotsrc.org/ubuntu/
+https://mirror.asergo.com/ubuntu/
+https://mirror.netsite.dk/ubuntu/archive/
+https://mirrors.c0urier.net/linux/ubuntu/
+#LOC:EC
+http://mirror.cedia.org.ec/ubuntu/
+http://mirror.espol.edu.ec/ubuntu/
+#LOC:EE
+http://ftp.aso.ee/ubuntu/
+https://mirrors.xtom.ee/ubuntu/
+#LOC:ES
+http://dafi.inf.um.es/ubuntu/
+http://ftp.caliu.cat/pub/distribucions/ubuntu/archive/
+http://ftp.udc.es/ubuntu/
+http://mirror.tedra.es/ubuntu/
+http://softlibre.unizar.es/ubuntu/archive/
+http://ubuntu.cica.es/ubuntu/
+http://ubuntu.grn.cat/ubuntu/
+https://ftp.csuc.cat/ubuntu/archive/
+https://labs.eif.urjc.es/mirror/ubuntu/
+https://ubuntu.uvigo.es/
+#LOC:FI
+http://mirrors.nic.funet.fi/ubuntu/
+https://mirror.5i.fi/ubuntu/
+#LOC:FR
+http://distrib-coffee.ipsl.jussieu.fr/pub/linux/ubuntu/
+http://miroir.univ-lorraine.fr/ubuntu/
+http://mirror.plusserver.com/ubuntu/ubuntu/
+http://mirrors.ircam.fr/pub/ubuntu/archive/
+http://ubuntu.mirror.serverloft.de/ubuntu/
+http://ubuntu.mirrors.ovh.net/ubuntu/
+http://ubuntu.univ-nantes.fr/ubuntu/
+http://ubuntu.univ-reims.fr/ubuntu/
+https://ftp.u-picardie.fr/mirror/ubuntu/ubuntu/
+https://mirror.johnnybegood.fr/ubuntu/
+https://mirror.ubuntu.ikoula.com/
+https://ubuntu.lafibre.info/ubuntu/
+https://www-ftp.lip6.fr/pub/linux/distributions/Ubuntu/archive/
+#LOC:GB
+http://archive.ubuntu.com/ubuntu/
+http://mirror.as29550.net/archive.ubuntu.com/
+http://mirror.bytemark.co.uk/ubuntu/
+http://mirror.cov.ukservers.com/ubuntu/
+http://mirror.eu-lo.kamatera.com/ubuntu/
+http://mirror.freethought-internet.co.uk/ubuntu/
+http://mirror.mythic-beasts.com/ubuntu/
+http://mirror.ox.ac.uk/sites/archive.ubuntu.com/ubuntu/
+http://mirror.sov.uk.goscomb.net/ubuntu/
+http://mirror.vorboss.net/ubuntu-archive/
+http://mirrors.coreix.net/ubuntu/
+http://mirrors.melbourne.co.uk/ubuntu/
+http://mirrors.ukfast.co.uk/sites/archive.ubuntu.com/
+http://ubuntu.mirrors.uk2.net/ubuntu/
+http://ubuntu.positive-internet.com/ubuntu/
+http://www.mirrorservice.org/sites/archive.ubuntu.com/ubuntu/
+https://mirror.pulsant.com/sites/ubuntu-archive/
+https://mirror.vinehost.net/ubuntu/
+https://mirrors.gethosted.online/ubuntu/
+https://uk.mirrors.clouvider.net/ubuntu/
+#LOC:GE
+http://ubuntu.grena.ge/ubuntu/
+#LOC:GL
+http://mirror.greennet.gl/ubuntu/
+#LOC:GR
+http://ftp.cc.uoc.gr/mirrors/linux/ubuntu/packages/
+http://ftp.ntua.gr/ubuntu/
+http://ubuntu.otenet.gr/
+#LOC:HK
+http://hk.mirrors.thegigabit.com/ubuntu/
+http://mirror-hk.koddos.net/ubuntu/
+http://mirror.as.kamatera.com/ubuntu/
+http://www.ubuntu.org.tw/
+https://mirror.xtom.com.hk/ubuntu/
+#LOC:HR
+http://ubuntu.grad.hr/ubuntu/
+#LOC:HU
+http://repo.jztkft.hu/ubuntu/
+https://mirror.niif.hu/ubuntu/
+https://mirrors.sth.sze.hu/ubuntu/
+https://quantum-mirror.hu/mirrors/pub/ubuntu/
+#LOC:ID
+http://kartolo.sby.datautama.net.id/ubuntu/
+http://kebo.pens.ac.id/ubuntu/
+http://mirror.beon.co.id/ubuntu/
+http://mirror.biznetgio.com/ubuntu/
+http://mirror.cepatcloud.id/ubuntu/
+http://mirror.cloudxchange.id/ubuntu/
+http://mirror.deace.id/ubuntu/
+http://mirror.poliwangi.ac.id/ubuntu/
+http://mirror.telkomuniversity.ac.id/ubuntu/
+http://mirror.unej.ac.id/ubuntu/
+http://repo.ugm.ac.id/ubuntu/
+http://suro.ubaya.ac.id/ubuntu/
+https://buaya.klas.or.id/ubuntu/
+https://linux.domainesia.com/ubuntu/ubuntu-archive/
+https://mirror.amscloud.co.id/ubuntu/
+https://mirror.citraix.net/ubuntu/
+https://mirror.dewabiz.com/ubuntu/
+https://mirror.faizuladib.com/ubuntu/
+https://mirror.gi.co.id/ubuntu/
+https://mirror.nevacloud.com/ubuntu/ubuntu-archive/
+https://mirror.papua.go.id/ubuntu/
+https://mirror.repository.id/ubuntu/
+https://mirror.unair.ac.id/ubuntu/
+https://mirrors.idcloudhost.com/ubuntu/
+https://mr.heru.id/ubuntu/
+https://repo.usk.ac.id/ubuntu/
+https://sby.mirror.bignet.id/ubuntu/
+#LOC:IE
+http://ftp.heanet.ie/pub/ubuntu/
+https://mirror.webworld.ie/ubuntu/
+#LOC:IL
+http://mirror.il-jr.kamatera.com/ubuntu/
+http://mirror.il-pt.kamatera.com/ubuntu/
+http://mirror.il-rh.kamatera.com/ubuntu/
+http://mirror.il-ta.kamatera.com/ubuntu/
+http://mirror.il.kamatera.com/ubuntu/
+http://mirror.isoc.org.il/pub/ubuntu/
+http://rep-ubuntu-il.upress.io/ubuntu/
+#LOC:IN
+http://ftp.iitm.ac.in/ubuntu/
+http://mirror.cse.iitk.ac.in/ubuntu/
+http://mirrors.piconets.webwerks.in/ubuntu-mirror/ubuntu/
+http://repos.del.extreme-ix.org/ubuntu/
+http://ubuntu.hbcse.tifr.res.in/ubuntu/
+https://in.mirror.coganng.com/ubuntu-ports/
+https://in.mirror.coganng.com/ubuntu/
+https://mirrors.nxtgen.com/ubuntu-mirror/ubuntu/
+https://repo.extreme-ix.org/ubuntu/
+https://ubuntu-archive.mirror.net.in/
+https://ubuntu-ports.mirror.net.in/
+#LOC:IR
+http://archive.ubuntu.asiatech.ir/
+http://mirror.aminidc.com/ubuntu/
+http://mirror.faraso.org/ubuntu/
+http://repo.iut.ac.ir/repo/Ubuntu/
+http://ubuntu.byteiran.com/ubuntu/
+https://archive.ubuntu.petiak.ir/ubuntu/
+https://ir.ubuntu.sindad.cloud/ubuntu/
+https://mirror.0-1.cloud/ubuntu/
+https://mirror.iranserver.com/ubuntu/
+https://mirror.rasanegar.com/ubuntu/
+https://mirrors.pardisco.co/ubuntu/
+https://ubuntu-mirror.kimiahost.com/
+https://ubuntu.bardia.tech/
+https://ubuntu.hostiran.ir/ubuntuarchive/
+https://ubuntu.shatel.ir/ubuntu/
+#LOC:IS
+http://ubuntu.hysing.is/ubuntu/
+https://is.mirror.flokinet.net/ubuntu/
+https://mirrors.opensource.is/ubuntu/
+#LOC:IT
+http://giano.com.dist.unige.it/ubuntu/
+https://it1.mirror.vhosting-it.com/ubuntu/
+https://it2.mirror.vhosting-it.com/ubuntu/
+https://ubuntu.mirror.garr.it/ubuntu/
+#LOC:JP
+http://archive.g4t1.pro/ubuntu/
+http://ftp.jaist.ac.jp/pub/Linux/ubuntu/
+http://ftp.riken.jp/Linux/ubuntu/
+http://ftp.tsukuba.wide.ad.jp/Linux/ubuntu/
+http://mirror.fairway.ne.jp/ubuntu/
+http://ubuntutym.u-toyama.ac.jp/ubuntu/
+http://www.ftp.ne.jp/Linux/packages/ubuntu/archive/
+https://ftp.udx.icscoe.jp/Linux/ubuntu/
+https://jp.mirror.coganng.com/ubuntu-ports/
+https://jp.mirror.coganng.com/ubuntu/
+https://linux.yz.yamagata-u.ac.jp/ubuntu/
+https://mirror.nishi.network/ubuntu-ports/
+https://mirror.nishi.network/ubuntu/
+#LOC:KG
+http://mir.linux.kg/ubuntu/
+#LOC:KH
+https://mirror.sabay.com.kh/ubuntu/
+#LOC:KR
+http://ftp.daum.net/ubuntu/
+https://devpg.net/ubuntu/
+https://ftp.lanet.kr/ubuntu-ports/
+https://ftp.lanet.kr/ubuntu/
+https://mirror.elice.io/ubuntu/
+https://mirror.hserver.kr/ubuntu/
+https://mirror.kakao.com/ubuntu/
+https://mirror.yuki.net.uk/ubuntu-ports/
+https://mirror.yuki.net.uk/ubuntu/
+#LOC:KZ
+http://mirror.hoster.kz/ubuntu/
+http://mirror.neolabs.kz/ubuntu/
+http://mirror.ps.kz/ubuntu/
+#LOC:LT
+http://ftp.litnet.lt/ubuntu/
+http://ubuntu-archive.mirror.serveriai.lt/
+http://ubuntu.mirror.vu.lt/ubuntu/
+#LOC:LU
+http://ubuntu.mirror.root.lu/ubuntu/
+#LOC:LV
+http://mirror.cloudhosting.lv/ubuntu/
+http://ubuntu-arch.linux.edu.lv/ubuntu/
+http://ubuntu.koyanet.lv/ubuntu/
+#LOC:MA
+https://mirror.marwan.ma/ubuntu/
+#LOC:MD
+http://mirror.as43289.net/ubuntu/
+http://mirrors.mivocloud.com/ubuntu/
+#LOC:MG
+http://ubuntu.dts.mg/ubuntu/
+#LOC:MK
+http://mirror.onevip.mk/ubuntu/
+http://mirror.t-home.mk/ubuntu/
+#LOC:MN
+http://mirror.datacenter.mn/ubuntu/
+#LOC:MU
+https://ubuntu-mirror.cloud.mu/ubuntu-ports/
+https://ubuntu-mirror.cloud.mu/ubuntu/
+#LOC:MY
+http://my.mirrors.thegigabit.com/ubuntu/
+http://ubuntu.mirror.myduniahost.com/ubuntu/
+http://ubuntu.tuxuri.com/ubuntu/
+https://mirrors.gbnetwork.com/ubuntu/
+https://mirrors.ipserverone.com/ubuntu/
+#LOC:NA
+http://download.nust.na/pub/ubuntu/ubuntu/
+#LOC:NC
+http://archive.ubuntu.nautile.nc/ubuntu/
+http://ubuntu.lagoon.nc/ubuntu/
+#LOC:NL
+ftp://ftpserv.tudelft.nl/pub/Linux/archive.ubuntu.com/
+http://ftp.nluug.nl/os/Linux/distr/ubuntu/
+http://ftp.snt.utwente.nl/pub/os/linux/ubuntu/
+http://ftp.tudelft.nl/archive.ubuntu.com/
+http://mirror.eu.kamatera.com/ubuntu/
+http://mirror.hostnet.nl/ubuntu/archive/
+http://mirror.nforce.com/pub/linux/ubuntu/
+http://mirror.nl.datapacket.com/ubuntu/
+http://mirror.previder.nl/ubuntu/
+http://mirror.serverion.com/ubuntu/
+http://mirror.serverius.net/ubuntu/
+http://mirror.transip.net/ubuntu/ubuntu/
+http://mirror.vpgrp.io/ubuntu/
+http://nl.archive.ubuntu.com/ubuntu/
+http://nl3.archive.ubuntu.com/ubuntu/
+http://osmirror.rug.nl/ubuntu/
+http://ubuntu.mirror.cambrium.nl/ubuntu/
+http://ubuntu.mirror.true.nl/ubuntu/
+https://mirror.lyrahosting.com/ubuntuarchive/
+https://mirror.nl.altushost.com/ubuntu/
+https://mirror.nl.leaseweb.net/ubuntu/
+https://mirrors.evoluso.com/ubuntu/
+https://mirrors.hostiserver.com/ubuntu/
+https://mirrors.xtom.nl/ubuntu/
+https://nl.mirrors.clouvider.net/ubuntu/
+https://ubuntu.mirror.wearetriple.com/archive/
+#LOC:NO
+http://ftp.uninett.no/ubuntu/
+http://no.archive.ubuntu.com/ubuntu/
+http://no.mirrors.blix.com/ubuntu/
+http://ubuntu.uib.no/archive/
+https://ubuntu.hi.no/archive/
+#LOC:NP
+http://ntc.net.np/ubuntu/
+http://ubuntu.ntc.net.np/ubuntu/
+#LOC:NZ
+http://mirror.fsmg.org.nz/ubuntu/
+http://ubuntu.mirrors.theom.nz/
+http://ucmirror.canterbury.ac.nz/ubuntu/
+https://mirror.2degrees.nz/ubuntu/
+#LOC:PH
+http://mirror.pregi.net/ubuntu/
+http://mirror.rise.ph/ubuntu/
+#LOC:PL
+http://ftp.agh.edu.pl/ubuntu/
+http://ftp.icm.edu.pl/pub/Linux/ubuntu/
+http://ftp.vectranet.pl/ubuntu/
+http://ubuntu.man.lodz.pl/ubuntu/
+http://ubuntu.task.gda.pl/ubuntu/
+https://ftp.psnc.pl/linux/ubuntu/
+#LOC:PR
+http://mirrors.upr.edu/ubuntu/
+#LOC:PT
+http://archive.ubuntumirror.dei.uc.pt/ubuntu/
+http://ftp.rnl.tecnico.ulisboa.pt/pub/ubuntu/archive/
+http://glua.ua.pt/pub/ubuntu/
+http://mirrors.up.pt/ubuntu/
+https://mirrors.ptisp.pt/ubuntu/
+#LOC:RO
+http://mirrors.nxthost.com/ubuntu/
+http://mirrors.pidginhost.com/ubuntu/
+https://mirror.efect.ro/ubuntu/archive/
+https://mirror.flokinet.net/ubuntu/
+https://mirrors.chroot.ro/ubuntu/
+https://mirrors.hostico.ro/ubuntu/archive/
+https://mirrors.nav.ro/ubuntu/
+https://ubuntu-mirror.magnetic-it.com/ubuntu/
+https://ubuntu.mirrors.orange.ro/ubuntu/
+#LOC:RU
+http://mirror.corbina.net/ubuntu/
+http://mirror.docker.ru/ubuntu/
+http://mirror.hyperdedic.ru/ubuntu/
+http://mirror.logol.ru/ubuntu/
+http://mirror.timeweb.ru/ubuntu/
+http://mirror.yandex.ru/ubuntu/
+http://mirrors.powernet.com.ru/ubuntu/
+https://mirror.linux-ia64.org/ubuntu/
+https://mirror.truenetwork.ru/ubuntu/
+#LOC:SA
+https://mirrors.isu.net.sa/apt-mirror/
+#LOC:SE
+http://ftp.acc.umu.se/ubuntu/
+http://ftp.lysator.liu.se/ubuntu/
+http://mirror.zetup.net/ubuntu/
+http://ubuntu.mirror.su.se/ubuntu/
+https://ftpmirror1.infania.net/ubuntu/
+https://mirror.bahnhof.net/ubuntu/
+https://mirror.se.altushost.com/ubuntu/
+#LOC:SG
+http://0ms.run/mirrors/ftp.udx.icscoe.jp/Linux/ubuntu/
+http://mirror.aktkn.sg/ubuntu/
+http://mirror.sg.gs/ubuntu/
+http://mirror.soonkeat.sg/ubuntu/
+http://ossmirror.mycloud.services/os/linux/ubuntu/
+https://mirror.coganng.com/ubuntu-ports/
+https://mirror.coganng.com/ubuntu/
+#LOC:SI
+http://ftp.arnes.si/pub/mirrors/ubuntu/
+#LOC:SK
+http://ftp.energotel.sk/pub/linux/ubuntu/
+http://tux.rainside.sk/ubuntu/
+https://mirror.vnet.sk/ubuntu/
+#LOC:TH
+http://mirror.thaidns.co.th/ubuntu/
+http://mirror1.ku.ac.th/ubuntu/
+http://mirror1.totbb.net/ubuntu/
+http://mirrors.psu.ac.th/ubuntu/
+https://mirror.kku.ac.th/ubuntu/
+https://mirrors.nipa.cloud/ubuntu/
+#LOC:TR
+http://mirror.kapteyan.com.tr/ubuntu/
+http://mirror.ni.net.tr/ubuntu/
+http://ubuntu.turhost.com/ubuntu/
+http://ubuntu.vargonen.com/ubuntu/
+https://ftp.linux.org.tr/ubuntu/
+https://kozyatagi.mirror.guzel.net.tr/ubuntu/
+https://mirror.alastyr.com/ubuntu/ubuntu-archive/
+https://mirror.onlinehosting.com.tr/ubuntu/
+https://mirror.rabisu.com/ubuntu/ubuntu-archive/
+https://mirror.sh.com.tr/ubuntu/
+https://mirror.verinomi.com/ubuntu/ubuntu-archive/
+#LOC:TW
+http://free.nchc.org.tw/ubuntu/
+http://ftp.mirror.tw/pub/ubuntu/ubuntu/
+http://ftp.tku.edu.tw/ubuntu/
+http://ftp.tw.debian.org/ubuntu/
+http://mirror.nwlab.tk/ubuntu/
+http://mirror01.idc.hinet.net/ubuntu/
+http://ubuntu.cs.nctu.edu.tw/ubuntu/
+https://ftp.tc.edu.tw/Linux/ubuntu/
+https://ftp.ubuntu-tw.net/ubuntu/
+https://mirror.ossplanet.net/ubuntu/
+https://tw1.mirror.blendbyte.net/ubuntu/
+https://ubuntu.ccns.ncku.edu.tw/ubuntu/
+#LOC:TZ
+http://deb-mirror.habari.co.tz/ubuntu/
+http://mirror.aptus.co.tz/pub/ubuntuarchive/
+#LOC:UA
+http://mirror.mirohost.net/ubuntu/
+http://ubuntu.colocall.net/ubuntu/
+http://ubuntu.mirrors.omnilance.com/ubuntu/
+http://ubuntu.org.ua/ubuntu/
+http://ubuntu.volia.net/ubuntu-archive/
+https://ubuntu.astra.in.ua/ubuntu/
+https://ubuntu.netforce.hosting/ubuntu/
+#LOC:US
+http://archive.linux.duke.edu/ubuntu/
+http://babylon.cs.uh.edu/mirror-sites/ubuntu/
+http://ftp.usf.edu/pub/ubuntu/
+http://ftp.ussg.iu.edu/linux/ubuntu/
+http://mirror.arizona.edu/ubuntu/
+http://mirror.brightridge.com/ubuntuarchive/
+http://mirror.cc.vt.edu/pub2/ubuntu/
+http://mirror.cogentco.com/pub/linux/ubuntu/
+http://mirror.cs.jmu.edu/pub/ubuntu/
+http://mirror.math.princeton.edu/pub/ubuntu/
+http://mirror.math.ucdavis.edu/ubuntu/
+http://mirror.metrocast.net/ubuntu/
+http://mirror.mrjester.net/ubuntu/archive/
+http://mirror.nodesdirect.com/ubuntu/
+http://mirror.pit.teraswitch.com/ubuntu/
+http://mirror.pnl.gov/ubuntu/
+http://mirror.rustytel.net/ubuntu/
+http://mirror.siena.edu/ubuntu/
+http://mirror.steadfastnet.com/ubuntu/
+http://mirror.team-cymru.com/ubuntu/
+http://mirror.team-cymru.org/ubuntu/
+http://mirror.umd.edu/ubuntu/
+http://mirror.uoregon.edu/ubuntu/
+http://mirror.us-midwest-1.nexcess.net/ubuntu/
+http://mirror.us-ny2.kamatera.com/ubuntu/
+http://mirror.us-sc.kamatera.com/ubuntu/
+http://mirror.us-tx.kamatera.com/ubuntu/
+http://mirror.vcu.edu/pub/gnu+linux/ubuntu/
+http://mirrors.accretive-networks.net/ubuntu/
+http://mirrors.advancedhosters.com/ubuntu/
+http://mirrors.arpnetworks.com/Ubuntu/
+http://mirrors.cat.pdx.edu/ubuntu/
+http://mirrors.cmich.edu/ubuntu/
+http://mirrors.codec-cluster.org/ubuntu/
+http://mirrors.gigenet.com/ubuntuarchive/
+http://mirrors.liquidweb.com/ubuntu/
+http://mirrors.lug.mtu.edu/ubuntu/
+http://mirrors.maine.edu/ubuntu/
+http://mirrors.mit.edu/ubuntu/
+http://mirrors.namecheap.com/ubuntu/
+http://mirrors.ocf.berkeley.edu/ubuntu/
+http://mirrors.rit.edu/ubuntu/
+http://mirrors.sonic.net/ubuntu/
+http://mirrors.syringanetworks.net/ubuntu-archive/
+http://mirrors.tripadvisor.com/ubuntu/
+http://mirrors.us.kernel.org/ubuntu/
+http://mirrors.usinternet.com/ubuntu/archive/
+http://mirrors.vcea.wsu.edu/ubuntu/
+http://mirrors.xmission.com/ubuntu/
+http://plug-mirror.rcac.purdue.edu/ubuntu/
+http://pubmirrors.dal.corespace.com/ubuntu/
+http://reflector.westga.edu/repos/Ubuntu/archive/
+http://repo.miserver.it.umich.edu/ubuntu/
+http://repos.forethought.net/ubuntu/
+http://ubuntu.cs.utah.edu/ubuntu/
+http://ubuntu.mirror.constant.com/
+http://ubuntu.mirror.frontiernet.net/ubuntu/
+http://ubuntu.mirrors.pair.com/archive/
+http://ubuntu.osuosl.org/ubuntu/
+http://ubuntu.phoenixnap.com/ubuntu/
+http://ubuntu.securedservers.com/
+http://www.club.cc.cmu.edu/pub/ubuntu/
+http://www.gtlib.gatech.edu/pub/ubuntu/
+https://atl.mirrors.clouvider.net/ubuntu/
+https://dal.mirrors.clouvider.net/ubuntu/
+https://la.mirrors.clouvider.net/ubuntu/
+https://lug.mines.edu/mirrors/ubuntu/
+https://mirror.clarkson.edu/ubuntu/
+https://mirror.cs.pitt.edu/ubuntu/archive/
+https://mirror.d.umn.edu/ubuntu/
+https://mirror.dal.nexril.net/ubuntu/
+https://mirror.enzu.com/ubuntu/
+https://mirror.fcix.net/ubuntu/
+https://mirror.hostduplex.com/ubuntu/
+https://mirror.lstn.net/ubuntu/
+https://mirror.mia.velocihost.net/ubuntu/
+https://mirror.servaxnet.com/ubuntu/
+https://mirror.ubuntu.serverforge.org/
+https://mirror.us.leaseweb.net/ubuntu/
+https://mirrors.bloomu.edu/ubuntu/
+https://mirrors.egr.msu.edu/ubuntu/
+https://mirrors.iu13.net/ubuntu/
+https://mirrors.ocf.berkeley.edu/ubuntu-ports/
+https://mirrors.sarak.as/ubuntu/
+https://mirrors.tscak.com/ubuntu/
+https://mirrors.wikimedia.org/ubuntu/
+https://mirrors.xtom.com/ubuntu/
+https://nyc.mirrors.clouvider.net/ubuntu/
+https://repo.ialab.dsu.edu/ubuntu/
+https://ubuntu.mirror.shastacoe.net/ubuntu/
+#LOC:UY
+http://repos.interior.edu.uy/ubuntu/
+https://ubuntu.repo.cure.edu.uy/mirror/
+#LOC:UZ
+http://mirror.dc.uz/ubuntu/
+http://ubuntu.snet.uz/ubuntu/
+#LOC:VN
+http://mirror.bizflycloud.vn/ubuntu/
+http://mirror.clearsky.vn/ubuntu/
+http://mirror.vietnix.vn/ubuntu/
+http://mirrors.nhanhoa.com/ubuntu/
+http://mirrors.vhost.vn/ubuntu/
+http://opensource.xtdv.net/ubuntu/
+https://mirrors.bkns.vn/ubuntu/
+#LOC:ZA
+http://mirror.hostafrica.co.za/ubuntu/
+http://mirror.wiru.co.za/ubuntu/
+http://ubuntu.mirror.ac.za/ubuntu/
+http://ubuntu.mirror.rain.co.za/ubuntu/

build/data/templates/gNewSense.info

@@ -0,0 +1,55 @@
+ChangelogURI: http://packages.debian.org/changelogs/pool/%s/%s/%s/%s_%s/changelog
+
+# gNS 3, to be based on Squeeze.
+Suite: parkes
+RepositoryType: deb
+BaseURI: http://archive.gnewsense.org/gnewsense/
+MatchURI: archive.gnewsense.org/gnewsense
+MirrorsFile: gNewSense.mirrors
+Description: gNewSense 3 - "parkes"
+Component: main
+CompDescription: Main supported software
+CompDescriptionLong: Core software
+
+Suite: parkes/updates
+RepositoryType: deb
+BaseURI: http://security.gnewsense.org/gnewsense
+MatchURI: security.gnewsense.org/security
+ParentSuite: parkes
+Description: Security updates
+
+# gNS 2.x, based on hardy
+Suite: deltah
+RepositoryType: deb
+BaseURI: http://archive.gnewsense.org/gnewsense/
+MatchURI: archive.gnewsense.org/gnewsense
+MirrorsFile: gNewSense.mirrors
+Description: gNewSense "deltah"
+Component: main
+CompDescription: Main supported software
+CompDescriptionLong: Core software
+Component: universe
+CompDescription: Other useful software
+CompDescriptionLong: Non-core useful software
+
+Suite: deltah-security
+ParentSuite: deltah
+RepositoryType: deb
+BaseURI: http://security.gnewsense.org/gnewsense/
+MatchURI: archive.gnewsense.org/gnewsense|security.gnewsense.org
+Description: Important security updates
+
+Suite: deltah-updates
+ParentSuite: deltah
+RepositoryType: deb
+BaseURI: http://archive.gnewsense.org/gnewsense/
+MatchURI: archive.gnewsense.org/gnewsense
+Description: Unsupported updates
+
+Suite: deltah-backports
+ParentSuite: deltah
+RepositoryType: deb
+BaseURI: http://archive.gnewsense.org/gnewsense/
+MatchURI: archive.gnewsense.org/gnewsense
+Description: Package Backports
+

build/data/templates/gNewSense.mirrors

@@ -0,0 +1,489 @@
+
+#LOC:AD
+http://ad.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:AE
+http://ae.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:AF
+http://af.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:AG
+http://ag.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:AI
+http://ai.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:AL
+http://al.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:AM
+http://am.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:AN
+http://an.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:AO
+http://ao.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:AQ
+http://aq.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:AR
+http://ar.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:AS
+http://as.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:AT
+http://at.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:AU
+http://au.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:AW
+http://aw.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:AX
+http://ax.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:AZ
+http://az.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:BA
+http://ba.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:BB
+http://bb.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:BD
+http://bd.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:BE
+http://be.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:BF
+http://bf.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:BG
+http://bg.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:BH
+http://bh.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:BI
+http://bi.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:BJ
+http://bj.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:BM
+http://bm.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:BN
+http://bn.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:BO
+http://bo.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:BR
+http://br.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:BS
+http://bs.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:BT
+http://bt.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:BV
+http://bv.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:BW
+http://bw.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:BY
+http://by.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:BZ
+http://bz.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:CA
+http://ca.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:CC
+http://cc.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:CD
+http://cd.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:CF
+http://cf.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:CG
+http://cg.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:CH
+http://ch.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:CI
+http://ci.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:CK
+http://ck.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:CL
+http://cl.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:CM
+http://cm.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:CN
+http://cn.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:CO
+http://co.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:CR
+http://cr.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:CU
+http://cu.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:CV
+http://cv.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:CX
+http://cx.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:CY
+http://cy.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:CZ
+http://cz.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:DE
+http://de.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:DJ
+http://dj.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:DK
+http://dk.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:DM
+http://dm.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:DO
+http://do.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:DZ
+http://dz.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:EC
+http://ec.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:EE
+http://ee.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:EG
+http://eg.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:EH
+http://eh.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:ER
+http://er.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:ES
+http://es.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:ET
+http://et.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:FI
+http://fi.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:FJ
+http://fj.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:FK
+http://fk.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:FM
+http://fm.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:FO
+http://fo.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:FR
+http://fr.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:GA
+http://ga.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:GB
+http://gb.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:GD
+http://gd.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:GE
+http://ge.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:GF
+http://gf.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:GG
+http://gg.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:GH
+http://gh.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:GI
+http://gi.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:GL
+http://gl.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:GM
+http://gm.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:GN
+http://gn.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:GP
+http://gp.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:GQ
+http://gq.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:GR
+http://gr.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:GS
+http://gs.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:GT
+http://gt.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:GU
+http://gu.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:GW
+http://gw.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:GY
+http://gy.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:HK
+http://hk.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:HM
+http://hm.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:HN
+http://hn.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:HR
+http://hr.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:HT
+http://ht.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:HU
+http://hu.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:ID
+http://id.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:IE
+http://ie.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:IL
+http://il.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:IM
+http://im.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:IN
+http://in.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:IO
+http://io.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:IQ
+http://iq.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:IR
+http://ir.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:IS
+http://is.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:IT
+http://it.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:JE
+http://je.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:JM
+http://jm.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:JO
+http://jo.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:JP
+http://jp.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:KE
+http://ke.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:KG
+http://kg.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:KH
+http://kh.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:KI
+http://ki.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:KM
+http://km.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:KN
+http://kn.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:KP
+http://kp.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:KR
+http://kr.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:KW
+http://kw.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:KY
+http://ky.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:KZ
+http://kz.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:LA
+http://la.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:LB
+http://lb.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:LC
+http://lc.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:LI
+http://li.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:LK
+http://lk.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:LR
+http://lr.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:LS
+http://ls.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:LT
+http://lt.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:LU
+http://lu.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:LV
+http://lv.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:LY
+http://ly.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:MA
+http://ma.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:MC
+http://mc.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:MD
+http://md.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:ME
+http://me.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:MG
+http://mg.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:MH
+http://mh.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:MK
+http://mk.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:ML
+http://ml.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:MM
+http://mm.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:MN
+http://mn.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:MO
+http://mo.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:MP
+http://mp.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:MQ
+http://mq.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:MR
+http://mr.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:MS
+http://ms.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:MT
+http://mt.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:MU
+http://mu.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:MV
+http://mv.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:MW
+http://mw.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:MX
+http://mx.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:MY
+http://my.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:MZ
+http://mz.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:NA
+http://na.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:NC
+http://nc.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:NE
+http://ne.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:NF
+http://nf.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:NG
+http://ng.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:NI
+http://ni.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:NL
+http://nl.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:NO
+http://no.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:NP
+http://np.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:NR
+http://nr.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:NU
+http://nu.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:NZ
+http://nz.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:OM
+http://om.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:PA
+http://pa.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:PE
+http://pe.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:PF
+http://pf.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:PG
+http://pg.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:PH
+http://ph.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:PK
+http://pk.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:PL
+http://pl.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:PM
+http://pm.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:PN
+http://pn.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:PR
+http://pr.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:PS
+http://ps.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:PT
+http://pt.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:PW
+http://pw.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:PY
+http://py.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:QA
+http://qa.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:RE
+http://re.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:RO
+http://ro.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:RS
+http://rs.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:RU
+http://ru.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:RW
+http://rw.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:SA
+http://sa.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:SB
+http://sb.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:SC
+http://sc.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:SD
+http://sd.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:SE
+http://se.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:SG
+http://sg.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:SH
+http://sh.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:SI
+http://si.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:SJ
+http://sj.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:SK
+http://sk.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:SL
+http://sl.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:SM
+http://sm.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:SN
+http://sn.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:SO
+http://so.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:SR
+http://sr.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:ST
+http://st.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:SV
+http://sv.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:SY
+http://sy.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:SZ
+http://sz.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:TC
+http://tc.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:TD
+http://td.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:TF
+http://tf.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:TG
+http://tg.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:TH
+http://th.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:TJ
+http://tj.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:TK
+http://tk.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:TL
+http://tl.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:TM
+http://tm.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:TN
+http://tn.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:TO
+http://to.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:TR
+http://tr.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:TT
+http://tt.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:TV
+http://tv.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:TW
+http://tw.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:TZ
+http://tz.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:UA
+http://ua.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:UG
+http://ug.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:UM
+http://um.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:US
+http://us.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:UY
+http://uy.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:UZ
+http://uz.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:VA
+http://va.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:VC
+http://vc.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:VE
+http://ve.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:VG
+http://vg.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:VI
+http://vi.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:VN
+http://vn.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:VU
+http://vu.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:WF
+http://wf.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:WS
+http://ws.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:YE
+http://ye.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:YT
+http://yt.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:ZA
+http://za.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:ZM
+http://zm.archive.gnewsense.org/gnewsense-metad/gnewsense/
+#LOC:ZW
+http://zw.archive.gnewsense.org/gnewsense-metad/gnewsense/

build/lib.linux-x86_64-cpython-310/apt/__init__.py

@@ -0,0 +1,38 @@
+#  Copyright (c) 2005-2009 Canonical
+#
+#  Author: Michael Vogt <[email protected]>
+#
+#  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
+# import the core of apt_pkg
+"""High-Level Interface for working with apt."""
+from __future__ import print_function
+
+import apt_pkg
+
+# import some fancy classes
+from apt.package import Package as Package, Version as Version
+from apt.cache import Cache as Cache, ProblemResolver as ProblemResolver
+Cache  # pyflakes
+ProblemResolver  # pyflakes
+Version  # pyflakes
+from apt.cdrom import Cdrom as Cdrom
+
+# init the package system, but do not re-initialize config
+if "APT" not in apt_pkg.config:
+    apt_pkg.init_config()
+apt_pkg.init_system()
+
+__all__ = ['Cache', 'Cdrom', 'Package']

build/lib.linux-x86_64-cpython-310/apt/auth.py

@@ -0,0 +1,309 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+# auth - authentication key management
+#
+#  Copyright (c) 2004 Canonical
+#  Copyright (c) 2012 Sebastian Heinlein
+#
+#  Author: Michael Vogt <[email protected]>
+#          Sebastian Heinlein <[email protected]>
+#
+#  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
+"""Handle GnuPG keys used to trust signed repositories."""
+
+from __future__ import print_function
+
+import errno
+import os
+import os.path
+import shutil
+import subprocess
+import sys
+import tempfile
+
+import apt_pkg
+from apt_pkg import gettext as _
+
+from typing import List, Optional, Tuple
+
+
+class AptKeyError(Exception):
+    pass
+
+
+class AptKeyIDTooShortError(AptKeyError):
+    """Internal class do not rely on it."""
+
+
+class TrustedKey(object):
+
+    """Represents a trusted key."""
+
+    def __init__(self, name, keyid, date):
+        # type: (str, str, str) -> None
+        self.raw_name = name
+        # Allow to translated some known keys
+        self.name = _(name)
+        self.keyid = keyid
+        self.date = date
+
+    def __str__(self):
+        # type: () -> str
+        return "%s\n%s %s" % (self.name, self.keyid, self.date)
+
+
+def _call_apt_key_script(*args, **kwargs):
+    # type: (str, Optional[str]) -> str
+    """Run the apt-key script with the given arguments."""
+    conf = None
+    cmd = [apt_pkg.config.find_file("Dir::Bin::Apt-Key", "/usr/bin/apt-key")]
+    cmd.extend(args)
+    env = os.environ.copy()
+    env["LANG"] = "C"
+    env["APT_KEY_DONT_WARN_ON_DANGEROUS_USAGE"] = "1"
+    try:
+        if apt_pkg.config.find_dir("Dir") != "/":
+            # If the key is to be installed into a chroot we have to export the
+            # configuration from the chroot to the apt-key script by using
+            # a temporary APT_CONFIG file. The apt-key script uses apt-config
+            # shell internally
+            conf = tempfile.NamedTemporaryFile(
+                prefix="apt-key", suffix=".conf")
+            conf.write(apt_pkg.config.dump().encode("UTF-8"))
+            conf.flush()
+            env["APT_CONFIG"] = conf.name
+        proc = subprocess.Popen(cmd, env=env, universal_newlines=True,
+                                stdin=subprocess.PIPE,
+                                stdout=subprocess.PIPE,
+                                stderr=subprocess.PIPE)
+
+        stdin = kwargs.get("stdin", None)
+
+        output, stderr = proc.communicate(stdin)  # type: str, str
+
+        if proc.returncode:
+            raise AptKeyError(
+                "The apt-key script failed with return code %s:\n"
+                "%s\n"
+                "stdout: %s\n"
+                "stderr: %s" % (
+                    proc.returncode, " ".join(cmd), output, stderr))
+        elif stderr:
+            sys.stderr.write(stderr)    # Forward stderr
+
+        return output.strip()
+    finally:
+        if conf is not None:
+            conf.close()
+
+
+def add_key_from_file(filename):
+    # type: (str) -> None
+    """Import a GnuPG key file to trust repositores signed by it.
+
+    Keyword arguments:
+    filename -- the absolute path to the public GnuPG key file
+    """
+    if not os.path.abspath(filename):
+        raise AptKeyError("An absolute path is required: %s" % filename)
+    if not os.access(filename, os.R_OK):
+        raise AptKeyError("Key file cannot be accessed: %s" % filename)
+    _call_apt_key_script("add", filename)
+
+
+def add_key_from_keyserver(keyid, keyserver):
+    # type: (str, str) -> None
+    """Import a GnuPG key file to trust repositores signed by it.
+
+    Keyword arguments:
+    keyid -- the long keyid (fingerprint) of the key, e.g.
+             A1BD8E9D78F7FE5C3E65D8AF8B48AD6246925553
+    keyserver -- the URL or hostname of the key server
+    """
+    tmp_keyring_dir = tempfile.mkdtemp()
+    try:
+        _add_key_from_keyserver(keyid, keyserver, tmp_keyring_dir)
+    except Exception:
+        raise
+    finally:
+        # We are racing with gpg when removing sockets, so ignore
+        # failure to delete non-existing files.
+        def onerror(func, path, exc_info):
+            # type: (object, str, Tuple[type, Exception, object]) -> None
+            if (isinstance(exc_info[1], OSError) and
+                exc_info[1].errno == errno.ENOENT):
+                return
+            raise
+
+        shutil.rmtree(tmp_keyring_dir, onerror=onerror)
+
+
+def _add_key_from_keyserver(keyid, keyserver, tmp_keyring_dir):
+    # type: (str, str, str) -> None
+    if len(keyid.replace(" ", "").replace("0x", "")) < (160 / 4):
+        raise AptKeyIDTooShortError(
+            "Only fingerprints (v4, 160bit) are supported")
+    # create a temp keyring dir
+    tmp_secret_keyring = os.path.join(tmp_keyring_dir, "secring.gpg")
+    tmp_keyring = os.path.join(tmp_keyring_dir, "pubring.gpg")
+    # default options for gpg
+    gpg_default_options = [
+        "gpg",
+        "--no-default-keyring", "--no-options",
+        "--homedir", tmp_keyring_dir,
+    ]
+    # download the key to a temp keyring first
+    res = subprocess.call(gpg_default_options + [
+        "--secret-keyring", tmp_secret_keyring,
+        "--keyring", tmp_keyring,
+        "--keyserver", keyserver,
+        "--recv", keyid,
+    ])
+    if res != 0:
+        raise AptKeyError("recv from '%s' failed for '%s'" % (
+            keyserver, keyid))
+    # FIXME:
+    # - with gnupg 1.4.18 the downloaded key is actually checked(!),
+    #   i.e. gnupg will not import anything that the server sends
+    #   into the keyring, so the below checks are now redundant *if*
+    #   gnupg 1.4.18 is used
+
+    # now export again using the long key id (to ensure that there is
+    # really only this one key in our keyring) and not someone MITM us
+    tmp_export_keyring = os.path.join(tmp_keyring_dir, "export-keyring.gpg")
+    res = subprocess.call(gpg_default_options + [
+        "--keyring", tmp_keyring,
+        "--output", tmp_export_keyring,
+        "--export", keyid,
+    ])
+    if res != 0:
+        raise AptKeyError("export of '%s' failed", keyid)
+    # now verify the fingerprint, this is probably redundant as we
+    # exported by the fingerprint in the previous command but its
+    # still good paranoia
+    output = subprocess.Popen(
+        gpg_default_options + [
+            "--keyring", tmp_export_keyring,
+            "--fingerprint",
+            "--batch",
+            "--fixed-list-mode",
+            "--with-colons",
+        ],
+        stdout=subprocess.PIPE,
+        universal_newlines=True).communicate()[0]
+    got_fingerprint = None
+    for line in output.splitlines():
+        if line.startswith("fpr:"):
+            got_fingerprint = line.split(":")[9]
+            # stop after the first to ensure no subkey trickery
+            break
+    # strip the leading "0x" is there is one and uppercase (as this is
+    # what gnupg is using)
+    signing_key_fingerprint = keyid.replace("0x", "").upper()
+    if got_fingerprint != signing_key_fingerprint:
+        # make the error match what gnupg >= 1.4.18 will output when
+        # it checks the key itself before importing it
+        raise AptKeyError(
+            "recv from '%s' failed for '%s'" % (
+                keyserver, signing_key_fingerprint))
+    # finally add it
+    add_key_from_file(tmp_export_keyring)
+
+
+def add_key(content):
+    # type: (str) -> None
+    """Import a GnuPG key to trust repositores signed by it.
+
+    Keyword arguments:
+    content -- the content of the GnuPG public key
+    """
+    _call_apt_key_script("adv", "--quiet", "--batch",
+                         "--import", "-", stdin=content)
+
+
+def remove_key(fingerprint):
+    # type: (str) -> None
+    """Remove a GnuPG key to no longer trust repositores signed by it.
+
+    Keyword arguments:
+    fingerprint -- the fingerprint identifying the key
+    """
+    _call_apt_key_script("rm", fingerprint)
+
+
+def export_key(fingerprint):
+    # type: (str) -> str
+    """Return the GnuPG key in text format.
+
+    Keyword arguments:
+    fingerprint -- the fingerprint identifying the key
+    """
+    return _call_apt_key_script("export", fingerprint)
+
+
+def update():
+    # type: () -> str
+    """Update the local keyring with the archive keyring and remove from
+    the local keyring the archive keys which are no longer valid. The
+    archive keyring is shipped in the archive-keyring package of your
+    distribution, e.g. the debian-archive-keyring package in Debian.
+    """
+    return _call_apt_key_script("update")
+
+
+def net_update():
+    # type: () -> str
+    """Work similar to the update command above, but get the archive
+    keyring from an URI instead and validate it against a master key.
+    This requires an installed wget(1) and an APT build configured to
+    have a server to fetch from and a master keyring to validate. APT
+    in Debian does not support this command and relies on update
+    instead, but Ubuntu's APT does.
+    """
+    return _call_apt_key_script("net-update")
+
+
+def list_keys():
+    # type: () -> List[TrustedKey]
+    """Returns a list of TrustedKey instances for each key which is
+    used to trust repositories.
+    """
+    # The output of `apt-key list` is difficult to parse since the
+    # --with-colons parameter isn't user
+    output = _call_apt_key_script("adv", "--with-colons", "--batch",
+                                  "--fixed-list-mode", "--list-keys")
+    res = []
+    for line in output.split("\n"):
+        fields = line.split(":")
+        if fields[0] == "pub":
+            keyid = fields[4]
+        if fields[0] == "uid":
+            uid = fields[9]
+            creation_date = fields[5]
+            key = TrustedKey(uid, keyid, creation_date)
+            res.append(key)
+    return res
+
+
+if __name__ == "__main__":
+    # Add some known keys we would like to see translated so that they get
+    # picked up by gettext
+    lambda: _("Ubuntu Archive Automatic Signing Key <[email protected]>")
+    lambda: _("Ubuntu CD Image Automatic Signing Key <[email protected]>")
+
+    apt_pkg.init()
+    for trusted_key in list_keys():
+        print(trusted_key)

build/lib.linux-x86_64-cpython-310/apt/cache.py

@@ -0,0 +1,1038 @@
+# cache.py - apt cache abstraction
+#
+#  Copyright (c) 2005-2009 Canonical
+#
+#  Author: Michael Vogt <[email protected]>
+#
+#  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
+
+from __future__ import print_function
+
+import fnmatch
+import os
+import warnings
+import weakref
+
+
+from typing import (Any, Callable, Dict, Iterator, List, Optional,
+                    Set, Tuple, Union, cast, KeysView)
+
+import apt_pkg
+from apt.package import Package, Version
+import apt.progress.text
+from apt.progress.base import AcquireProgress, InstallProgress, OpProgress
+
+
+class FetchCancelledException(IOError):
+    """Exception that is thrown when the user cancels a fetch operation."""
+
+
+class FetchFailedException(IOError):
+    """Exception that is thrown when fetching fails."""
+
+
+class UntrustedException(FetchFailedException):
+    """Exception that is thrown when fetching fails for trust reasons"""
+
+
+class LockFailedException(IOError):
+    """Exception that is thrown when locking fails."""
+
+
+class CacheClosedException(Exception):
+    """Exception that is thrown when the cache is used after close()."""
+
+
+class _WrappedLock(object):
+    """Wraps an apt_pkg.FileLock to raise LockFailedException.
+
+    Initialized using a directory path."""
+
+    def __init__(self, path):
+        # type: (str) -> None
+        self._path = path
+        self._lock = apt_pkg.FileLock(os.path.join(path, "lock"))
+
+    def __enter__(self):
+        # type: () -> None
+        try:
+            return self._lock.__enter__()
+        except apt_pkg.Error as e:
+            raise LockFailedException(("Failed to lock directory %s: %s") %
+                                       (self._path, e))
+
+    def __exit__(self, typ, value, traceback):
+        # type: (object, object, object) -> None
+        return self._lock.__exit__(typ, value, traceback)
+
+
+class Cache(object):
+    """Dictionary-like package cache.
+
+    The APT cache file contains a hash table mapping names of binary
+    packages to their metadata. A Cache object is the in-core
+    representation of the same. It provides access to APTs idea of the
+    list of available packages.
+
+    The cache can be used like a mapping from package names to Package
+    objects (although only getting items is supported).
+
+    Keyword arguments:
+    progress -- a OpProgress object,
+    rootdir  -- an alternative root directory. if that is given the system
+    sources.list and system lists/files are not read, only file relative
+    to the given rootdir,
+    memonly  -- build the cache in memory only.
+
+
+    .. versionchanged:: 1.0
+
+        The cache now supports package names with special architecture
+        qualifiers such as :all and :native. It does not export them
+        in :meth:`keys()`, though, to keep :meth:`keys()` a unique set.
+    """
+
+    def __init__(self, progress=None, rootdir=None, memonly=False):
+        # type: (Optional[OpProgress], Optional[str], bool) -> None
+        self._cache = cast(apt_pkg.Cache, None)  # type: apt_pkg.Cache
+        self._depcache = cast(apt_pkg.DepCache, None)  # type: apt_pkg.DepCache
+        self._records = cast(apt_pkg.PackageRecords, None)  # type: apt_pkg.PackageRecords # noqa
+        self._list = cast(apt_pkg.SourceList, None)  # type: apt_pkg.SourceList
+        self._callbacks = {}  # type: Dict[str, List[Union[Callable[..., None],str]]] # noqa
+        self._callbacks2 = {}  # type: Dict[str, List[Tuple[Callable[..., Any], Tuple[Any, ...], Dict[Any,Any]]]] # noqa
+        self._weakref = weakref.WeakValueDictionary()  # type: weakref.WeakValueDictionary[str, apt.Package] # noqa
+        self._weakversions = weakref.WeakSet()  # type: weakref.WeakSet[Version] # noqa
+        self._changes_count = -1
+        self._sorted_set = None  # type: Optional[List[str]]
+
+        self.connect("cache_post_open", "_inc_changes_count")
+        self.connect("cache_post_change", "_inc_changes_count")
+        if memonly:
+            # force apt to build its caches in memory
+            apt_pkg.config.set("Dir::Cache::pkgcache", "")
+        if rootdir:
+            rootdir = os.path.abspath(rootdir)
+            if os.path.exists(rootdir + "/etc/apt/apt.conf"):
+                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.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",
+                               rootdir + "/var/lib/dpkg/status")
+            # also set dpkg to the rootdir path so that its called for the
+            # --print-foreign-architectures call
+            apt_pkg.config.set("Dir::bin::dpkg",
+                               os.path.join(rootdir, "usr", "bin", "dpkg"))
+            # create required dirs/files when run with special rootdir
+            # automatically
+            self._check_and_create_required_dirs(rootdir)
+            # Call InitSystem so the change to Dir::State::Status is actually
+            # recognized (LP: #320665)
+            apt_pkg.init_system()
+
+        # Prepare a lock object (context manager for archive lock)
+        archive_dir = apt_pkg.config.find_dir("Dir::Cache::Archives")
+        self._archive_lock = _WrappedLock(archive_dir)
+
+        self.open(progress)
+
+    def fix_broken(self):
+        # type: () -> None
+        """Fix broken packages."""
+        self._depcache.fix_broken()
+
+    def _inc_changes_count(self):
+        # type: () -> None
+        """Increase the number of changes"""
+        self._changes_count += 1
+
+    def _check_and_create_required_dirs(self, rootdir):
+        # type: (str) -> None
+        """
+        check if the required apt directories/files are there and if
+        not create them
+        """
+        files = [
+            "/var/lib/dpkg/status",
+            "/etc/apt/sources.list",
+        ]
+        dirs = [
+            "/var/lib/dpkg",
+            "/etc/apt/",
+            "/var/cache/apt/archives/partial",
+            "/var/lib/apt/lists/partial",
+        ]
+        for d in dirs:
+            if not os.path.exists(rootdir + d):
+                #print "creating: ", rootdir + d
+                os.makedirs(rootdir + d)
+        for f in files:
+            if not os.path.exists(rootdir + f):
+                open(rootdir + f, "w").close()
+
+    def _run_callbacks(self, name):
+        # type: (str) -> None
+        """ internal helper to run a callback """
+        if name in self._callbacks:
+            for callback in self._callbacks[name]:
+                if callback == '_inc_changes_count':
+                    self._inc_changes_count()
+                else:
+                    callback()  # type: ignore
+
+        if name in self._callbacks2:
+            for callback, args, kwds in self._callbacks2[name]:
+                callback(self, *args, **kwds)
+
+    def open(self, progress=None):
+        # type: (Optional[OpProgress]) -> None
+        """ Open the package cache, after that it can be used like
+            a dictionary
+        """
+        if progress is None:
+            progress = apt.progress.base.OpProgress()
+        # close old cache on (re)open
+        self.close()
+        self.op_progress = progress
+        self._run_callbacks("cache_pre_open")
+
+        self._cache = apt_pkg.Cache(progress)
+        self._depcache = apt_pkg.DepCache(self._cache)
+        self._records = apt_pkg.PackageRecords(self._cache)
+        self._list = apt_pkg.SourceList()
+        self._list.read_main_list()
+        self._sorted_set = None
+        self.__remap()
+
+        self._have_multi_arch = len(apt_pkg.get_architectures()) > 1
+
+        progress.done()
+        self._run_callbacks("cache_post_open")
+
+    def __remap(self):
+        # type: () -> None
+        """Called after cache reopen() to relocate to new cache.
+
+        Relocate objects like packages and versions from the old
+        underlying cache to the new one.
+        """
+        for key in list(self._weakref.keys()):
+            try:
+                pkg = self._weakref[key]
+            except KeyError:
+                continue
+
+            try:
+                pkg._pkg = self._cache[pkg._pkg.name, pkg._pkg.architecture]
+            except LookupError:
+                del self._weakref[key]
+
+        for ver in list(self._weakversions):
+            # Package has been reseated above, reseat version
+            for v in ver.package._pkg.version_list:
+                # Requirements as in debListParser::SameVersion
+                if (v.hash == ver._cand.hash and
+                    (v.size == 0 or ver._cand.size == 0 or
+                     v.size == ver._cand.size) and
+                    v.multi_arch == ver._cand.multi_arch and
+                    v.ver_str == ver._cand.ver_str):
+                    ver._cand = v
+                    break
+            else:
+                self._weakversions.remove(ver)
+
+    def close(self):
+        # type: () -> None
+        """ Close the package cache """
+        # explicitely free the FDs that _records has open
+        del self._records
+        self._records = cast(apt_pkg.PackageRecords, None)
+
+    def __enter__(self):
+        # type: () -> Cache
+        """ Enter the with statement """
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        # type: (object, object, object) -> None
+        """ Exit the with statement """
+        self.close()
+
+    def __getitem__(self, key):
+        # type: (object) -> Package
+        """ look like a dictionary (get key) """
+        try:
+            key = str(key)
+            rawpkg = self._cache[key]
+        except KeyError:
+            raise KeyError('The cache has no package named %r' % key)
+
+        # It might be excluded due to not having a version or something
+        if not self.__is_real_pkg(rawpkg):
+            raise KeyError('The cache has no package named %r' % key)
+
+        pkg = self._rawpkg_to_pkg(rawpkg)
+
+        return pkg
+
+    def get(self, key, default=None):
+        # type: (object, object) -> Any
+        """Return *self*[*key*] or *default* if *key* not in *self*.
+
+        .. versionadded:: 1.1
+        """
+        try:
+            return self[key]
+        except KeyError:
+            return default
+
+    def _rawpkg_to_pkg(self, rawpkg):
+        # type: (apt_pkg.Package) -> Package
+        """Returns the apt.Package object for an apt_pkg.Package object.
+
+        .. versionadded:: 1.0.0
+        """
+        fullname = rawpkg.get_fullname(pretty=True)
+
+        return self._weakref.setdefault(fullname, Package(self, rawpkg))
+
+    def __iter__(self):
+        # type: () -> Iterator[Package]
+        # We iterate sorted over package names here. With this we read the
+        # package lists linearly if we need to access the package records,
+        # instead of having to do thousands of random seeks; the latter
+        # is disastrous if we use compressed package indexes, and slower than
+        # necessary for uncompressed indexes.
+        for pkgname in self.keys():
+            pkg = Package(self, self._cache[pkgname])
+            yield self._weakref.setdefault(pkgname, pkg)
+
+    def __is_real_pkg(self, rawpkg):
+        # type: (apt_pkg.Package) -> bool
+        """Check if the apt_pkg.Package provided is a real package."""
+        return rawpkg.has_versions
+
+    def has_key(self, key):
+        # type: (object) -> bool
+        return key in self
+
+    def __contains__(self, key):
+        # type: (object) -> bool
+        try:
+            return self.__is_real_pkg(self._cache[str(key)])
+        except KeyError:
+            return False
+
+    def __len__(self):
+        # type: () -> int
+        return len(self.keys())
+
+    def keys(self):
+        # type: () -> List[str]
+        if self._sorted_set is None:
+            self._sorted_set = sorted(p.get_fullname(pretty=True)
+                                      for p in self._cache.packages
+                                        if self.__is_real_pkg(p))
+        return list(self._sorted_set)  # We need a copy here, caller may modify
+
+    def get_changes(self):
+        # type: () -> List[Package]
+        """ Get the marked changes """
+        changes = []
+        marked_keep = self._depcache.marked_keep
+        for rawpkg in self._cache.packages:
+            if not marked_keep(rawpkg):
+                changes.append(self._rawpkg_to_pkg(rawpkg))
+        return changes
+
+    def upgrade(self, dist_upgrade=False):
+        # type: (bool) -> None
+        """Upgrade all packages.
+
+        If the parameter *dist_upgrade* is True, new dependencies will be
+        installed as well (and conflicting packages may be removed). The
+        default value is False.
+        """
+        self.cache_pre_change()
+        self._depcache.upgrade(dist_upgrade)
+        self.cache_post_change()
+
+    @property
+    def required_download(self):
+        # type: () -> int
+        """Get the size of the packages that are required to download."""
+        if self._records is None:
+            raise CacheClosedException(
+                "Cache object used after close() called")
+        pm = apt_pkg.PackageManager(self._depcache)
+        fetcher = apt_pkg.Acquire()
+        pm.get_archives(fetcher, self._list, self._records)
+        return fetcher.fetch_needed
+
+    @property
+    def required_space(self):
+        # type: () -> int
+        """Get the size of the additional required space on the fs."""
+        return self._depcache.usr_size
+
+    @property
+    def req_reinstall_pkgs(self):
+        # type: () -> Set[str]
+        """Return the packages not downloadable packages in reqreinst state."""
+        reqreinst = set()
+        get_candidate_ver = self._depcache.get_candidate_ver
+        states = frozenset((apt_pkg.INSTSTATE_REINSTREQ,
+                            apt_pkg.INSTSTATE_HOLD_REINSTREQ))
+        for pkg in self._cache.packages:
+            cand = get_candidate_ver(pkg)
+            if cand and not cand.downloadable and pkg.inst_state in states:
+                reqreinst.add(pkg.get_fullname(pretty=True))
+        return reqreinst
+
+    def _run_fetcher(self, fetcher, allow_unauthenticated):
+        # type: (apt_pkg.Acquire, Optional[bool]) -> int
+        if allow_unauthenticated is None:
+            allow_unauthenticated = apt_pkg.config.find_b("APT::Get::"
+                                        "AllowUnauthenticated", False)
+
+        untrusted = [item for item in fetcher.items if not item.is_trusted]
+        if untrusted and not allow_unauthenticated:
+            raise UntrustedException("Untrusted packages:\n%s" %
+                "\n".join(i.desc_uri for i in untrusted))
+
+        # do the actual fetching
+        res = fetcher.run()
+
+        # now check the result (this is the code from apt-get.cc)
+        failed = False
+        err_msg = ""
+        for item in fetcher.items:
+            if item.status == item.STAT_DONE:
+                continue
+            if item.STAT_IDLE:
+                continue
+            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.RESULT_CANCELLED:
+            raise FetchCancelledException(err_msg)
+        elif failed:
+            raise FetchFailedException(err_msg)
+        return res
+
+    def _fetch_archives(self,
+                        fetcher,                # type: apt_pkg.Acquire
+                        pm,                     # type: apt_pkg.PackageManager
+                        allow_unauthenticated=None,  # type: Optional[bool]
+                        ):
+        # type: (...) -> int
+        """ fetch the needed archives """
+        if self._records is None:
+            raise CacheClosedException(
+                "Cache object used after close() called")
+
+        # this may as well throw a SystemError exception
+        if not pm.get_archives(fetcher, self._list, self._records):
+            return False
+
+        # now run the fetcher, throw exception if something fails to be
+        # fetched
+        return self._run_fetcher(fetcher, allow_unauthenticated)
+
+    def fetch_archives(self,
+                       progress=None,        # type: Optional[AcquireProgress]
+                       fetcher=None,         # type: Optional[apt_pkg.Acquire]
+                       allow_unauthenticated=None,  # type: Optional[bool]
+                       ):
+        # type: (...) -> int
+        """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 occurred,
+        an exception of type :class:`FetchFailedException` or
+        :class:`FetchCancelledException` is raised.
+
+        The keyword-only parameter *allow_unauthenticated* specifies whether
+        to allow unauthenticated downloads. If not specified, it defaults to
+        the configuration option `APT::Get::AllowUnauthenticated`.
+
+        .. 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)
+
+        with self._archive_lock:
+            return self._fetch_archives(fetcher,
+                                        apt_pkg.PackageManager(self._depcache),
+                                        allow_unauthenticated)
+
+    def is_virtual_package(self, pkgname):
+        # type: (str) -> bool
+        """Return whether the package is a virtual package."""
+        try:
+            pkg = self._cache[pkgname]
+        except KeyError:
+            return False
+        else:
+            return bool(pkg.has_provides and not pkg.has_versions)
+
+    def get_providing_packages(self, pkgname, candidate_only=True,
+                               include_nonvirtual=False):
+        # type: (str, bool, bool) -> List[Package]
+        """Return a list of all packages providing a package.
+
+        Return a list of packages which provide the virtual package of the
+        specified name.
+
+        If 'candidate_only' is False, return all packages with at
+        least one version providing the virtual package. Otherwise,
+        return only those packages where the candidate version
+        provides the virtual package.
+
+        If 'include_nonvirtual' is True then it will search for all
+        packages providing pkgname, even if pkgname is not itself
+        a virtual pkg.
+        """
+
+        providers = set()  # type: Set[Package]
+        get_candidate_ver = self._depcache.get_candidate_ver
+        try:
+            vp = self._cache[pkgname]
+            if vp.has_versions and not include_nonvirtual:
+                return list(providers)
+        except KeyError:
+            return list(providers)
+
+        for provides, providesver, version in vp.provides_list:
+            rawpkg = version.parent_pkg
+            if not candidate_only or (version == get_candidate_ver(rawpkg)):
+                providers.add(self._rawpkg_to_pkg(rawpkg))
+        return list(providers)
+
+    def update(self, fetch_progress=None, pulse_interval=0,
+               raise_on_error=True, sources_list=None):
+        # type: (Optional[AcquireProgress], int, bool, Optional[str]) -> int
+        """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()
+        .
+        sources_list -- Update a alternative sources.list than the default.
+        Note that the sources.list.d directory is ignored in this case
+        """
+        with _WrappedLock(apt_pkg.config.find_dir("Dir::State::Lists")):
+            if sources_list:
+                old_sources_list = apt_pkg.config.find("Dir::Etc::sourcelist")
+                old_sources_list_d = (
+                    apt_pkg.config.find("Dir::Etc::sourceparts"))
+                old_cleanup = apt_pkg.config.find("APT::List-Cleanup")
+                apt_pkg.config.set("Dir::Etc::sourcelist",
+                                   os.path.abspath(sources_list))
+                apt_pkg.config.set("Dir::Etc::sourceparts", "xxx")
+                apt_pkg.config.set("APT::List-Cleanup", "0")
+                slist = apt_pkg.SourceList()
+                slist.read_main_list()
+            else:
+                slist = self._list
+
+            try:
+                if fetch_progress is None:
+                    fetch_progress = apt.progress.base.AcquireProgress()
+                try:
+                    res = self._cache.update(fetch_progress, slist,
+                                             pulse_interval)
+                except SystemError as e:
+                    raise FetchFailedException(e)
+                if not res and raise_on_error:
+                    raise FetchFailedException()
+                else:
+                    return res
+            finally:
+                if sources_list:
+                    apt_pkg.config.set("Dir::Etc::sourcelist",
+                                       old_sources_list)
+                    apt_pkg.config.set("Dir::Etc::sourceparts",
+                                       old_sources_list_d)
+                    apt_pkg.config.set("APT::List-Cleanup",
+                                       old_cleanup)
+
+    def install_archives(self, pm, install_progress):
+        # type: (apt_pkg.PackageManager, InstallProgress) -> int
+        """
+        The first parameter *pm* refers to an object returned by
+        apt_pkg.PackageManager().
+
+        The second parameter *install_progress* refers to an InstallProgress()
+        object of the module apt.progress.
+
+        This releases a system lock in newer versions, if there is any,
+        and reestablishes it afterwards.
+        """
+        # compat with older API
+        try:
+            install_progress.startUpdate()  # type: ignore
+        except AttributeError:
+            install_progress.start_update()
+
+        did_unlock = apt_pkg.pkgsystem_is_locked()
+        if did_unlock:
+            apt_pkg.pkgsystem_unlock_inner()
+
+        try:
+            res = install_progress.run(pm)
+        finally:
+            if did_unlock:
+                apt_pkg.pkgsystem_lock_inner()
+
+        try:
+            install_progress.finishUpdate()  # type: ignore
+        except AttributeError:
+            install_progress.finish_update()
+        return res
+
+    def commit(self,
+               fetch_progress=None,         # type: Optional[AcquireProgress]
+               install_progress=None,       # type: Optional[InstallProgress]
+               allow_unauthenticated=None,  # type: Optional[bool]
+               ):
+        # type: (...) -> bool
+        """Apply the marked changes to the cache.
+
+        The first parameter, *fetch_progress*, refers to a FetchProgress()
+        object as found in apt.progress, the default being
+        apt.progress.FetchProgress().
+
+        The second parameter, *install_progress*, is a
+        apt.progress.InstallProgress() object.
+
+        The keyword-only parameter *allow_unauthenticated* specifies whether
+        to allow unauthenticated downloads. If not specified, it defaults to
+        the configuration option `APT::Get::AllowUnauthenticated`.
+        """
+        # FIXME:
+        # use the new acquire/pkgmanager interface here,
+        # raise exceptions when a download or install fails
+        # and send proper error strings to the application.
+        # Current a failed download will just display "error"
+        # which is less than optimal!
+
+        if fetch_progress is None:
+            fetch_progress = apt.progress.base.AcquireProgress()
+        if install_progress is None:
+            install_progress = apt.progress.base.InstallProgress()
+
+        assert install_progress is not None
+
+        with apt_pkg.SystemLock():
+            pm = apt_pkg.PackageManager(self._depcache)
+            fetcher = apt_pkg.Acquire(fetch_progress)
+            with self._archive_lock:
+                while True:
+                    # fetch archives first
+                    res = self._fetch_archives(fetcher, pm,
+                                               allow_unauthenticated)
+
+                    # then install
+                    res = self.install_archives(pm, install_progress)
+                    if res == pm.RESULT_COMPLETED:
+                        break
+                    elif res == pm.RESULT_FAILED:
+                        raise SystemError("installArchives() failed")
+                    elif res == pm.RESULT_INCOMPLETE:
+                        pass
+                    else:
+                        raise SystemError("internal-error: unknown result "
+                                          "code from InstallArchives: %s" %
+                                          res)
+                    # reload the fetcher for media swaping
+                    fetcher.shutdown()
+        return (res == pm.RESULT_COMPLETED)
+
+    def clear(self):
+        # type: () -> None
+        """ Unmark all changes """
+        self._depcache.init()
+
+    # cache changes
+
+    def cache_post_change(self):
+        # type: () -> None
+        " called internally if the cache has changed, emit a signal then "
+        self._run_callbacks("cache_post_change")
+
+    def cache_pre_change(self):
+        # type: () -> None
+        """ called internally if the cache is about to change, emit
+            a signal then """
+        self._run_callbacks("cache_pre_change")
+
+    def connect(self, name, callback):
+        # type: (str, Union[Callable[..., None],str]) -> None
+        """Connect to a signal.
+
+        .. deprecated:: 1.0
+
+            Please use connect2() instead, as this function is very
+            likely to cause a memory leak.
+        """
+        if callback != '_inc_changes_count':
+            warnings.warn("connect() likely causes a reference"
+                          " cycle, use connect2() instead", RuntimeWarning, 2)
+        if name not in self._callbacks:
+            self._callbacks[name] = []
+        self._callbacks[name].append(callback)
+
+    def connect2(self, name, callback, *args, **kwds):
+        # type: (str, Callable[..., Any], object, object) -> None
+        """Connect to a signal.
+
+        The callback will be passed the cache as an argument, and
+        any arguments passed to this function. Make sure that, if you
+        pass a method of a class as your callback, your class does not
+        contain a reference to the cache.
+
+        Cyclic references to the cache can cause issues if the Cache object
+        is replaced by a new one, because the cache keeps a lot of objects and
+        tens of open file descriptors.
+
+        currently only used for cache_{post,pre}_{changed,open}.
+
+        .. versionadded:: 1.0
+        """
+        if name not in self._callbacks2:
+            self._callbacks2[name] = []
+        self._callbacks2[name].append((callback, args, kwds))
+
+    def actiongroup(self):
+        # type: () -> apt_pkg.ActionGroup
+        """Return an `ActionGroup` object for the current cache.
+
+        Action groups can be used to speedup actions. The action group is
+        active as soon as it is created, and disabled when the object is
+        deleted or when release() is called.
+
+        You can use the action group as a context manager, this is the
+        recommended way::
+
+            with cache.actiongroup():
+                for package in my_selected_packages:
+                    package.mark_install()
+
+        This way, the action group is automatically released as soon as the
+        with statement block is left. It also has the benefit of making it
+        clear which parts of the code run with a action group and which
+        don't.
+        """
+        return apt_pkg.ActionGroup(self._depcache)
+
+    @property
+    def dpkg_journal_dirty(self):
+        # type: () -> bool
+        """Return True if the dpkg was interrupted
+
+        All dpkg operations will fail until this is fixed, the action to
+        fix the system if dpkg got interrupted is to run
+        'dpkg --configure -a' as root.
+        """
+        dpkg_status_dir = os.path.dirname(
+            apt_pkg.config.find_file("Dir::State::status"))
+        for f in os.listdir(os.path.join(dpkg_status_dir, "updates")):
+            if fnmatch.fnmatch(f, "[0-9]*"):
+                return True
+        return False
+
+    @property
+    def broken_count(self):
+        # type: () -> int
+        """Return the number of packages with broken dependencies."""
+        return self._depcache.broken_count
+
+    @property
+    def delete_count(self):
+        # type: () -> int
+        """Return the number of packages marked for deletion."""
+        return self._depcache.del_count
+
+    @property
+    def install_count(self):
+        # type: () -> int
+        """Return the number of packages marked for installation."""
+        return self._depcache.inst_count
+
+    @property
+    def keep_count(self):
+        # type: () -> int
+        """Return the number of packages marked as keep."""
+        return self._depcache.keep_count
+
+
+class ProblemResolver(object):
+    """Resolve problems due to dependencies and conflicts.
+
+    The first argument 'cache' is an instance of apt.Cache.
+    """
+
+    def __init__(self, cache):
+        # type: (Cache) -> None
+        self._resolver = apt_pkg.ProblemResolver(cache._depcache)
+        self._cache = cache
+
+    def clear(self, package):
+        # type: (Package) -> None
+        """Reset the package to the default state."""
+        self._resolver.clear(package._pkg)
+
+    def protect(self, package):
+        # type: (Package) -> None
+        """Protect a package so it won't be removed."""
+        self._resolver.protect(package._pkg)
+
+    def remove(self, package):
+        # type: (Package) -> None
+        """Mark a package for removal."""
+        self._resolver.remove(package._pkg)
+
+    def resolve(self):
+        # type: () -> None
+        """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):
+        # type: () -> None
+        """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
+
+
+class Filter(object):
+    """ Filter base class """
+
+    def apply(self, pkg):
+        # type: (Package) -> bool
+        """ Filter function, return True if the package matchs a
+            filter criteria and False otherwise
+        """
+        return True
+
+
+class MarkedChangesFilter(Filter):
+    """ Filter that returns all marked changes """
+
+    def apply(self, pkg):
+        # type: (Package) -> bool
+        if pkg.marked_install or pkg.marked_delete or pkg.marked_upgrade:
+            return True
+        else:
+            return False
+
+
+class InstalledFilter(Filter):
+    """Filter that returns all installed packages.
+
+    .. versionadded:: 1.0.0
+    """
+
+    def apply(self, pkg):
+        # type: (Package) -> bool
+        return pkg.is_installed
+
+
+class _FilteredCacheHelper(object):
+    """Helper class for FilteredCache to break a reference cycle."""
+
+    def __init__(self, cache):
+        # type: (Cache) -> None
+        # Do not keep a reference to the cache, or you have a cycle!
+
+        self._filtered = {}  # type: Dict[str,bool]
+        self._filters = []  # type: List[Filter]
+        cache.connect2("cache_post_change", self.filter_cache_post_change)
+        cache.connect2("cache_post_open", self.filter_cache_post_change)
+
+    def _reapply_filter(self, cache):
+        # type: (Cache) -> None
+        " internal helper to refilter "
+        # Do not keep a reference to the cache, or you have a cycle!
+        self._filtered = {}
+        for pkg in cache:
+            for f in self._filters:
+                if f.apply(pkg):
+                    self._filtered[pkg.name] = True
+                    break
+
+    def set_filter(self, filter):
+        # type: (Filter) -> None
+        """Set the current active filter."""
+        self._filters = []
+        self._filters.append(filter)
+
+    def filter_cache_post_change(self, cache):
+        # type: (Cache) -> None
+        """Called internally if the cache changes, emit a signal then."""
+        # Do not keep a reference to the cache, or you have a cycle!
+        self._reapply_filter(cache)
+
+
+class FilteredCache(object):
+    """ A package cache that is filtered.
+
+        Can work on a existing cache or create a new one
+    """
+
+    def __init__(self, cache=None, progress=None):
+        # type: (Optional[Cache], Optional[OpProgress]) -> None
+        if cache is None:
+            self.cache = Cache(progress)
+        else:
+            self.cache = cache
+        self._helper = _FilteredCacheHelper(self.cache)
+
+    def __len__(self):
+        # type: () -> int
+        return len(self._helper._filtered)
+
+    def __getitem__(self, key):
+        # type: (str) -> Package
+        return self.cache[key]
+
+    def __iter__(self):
+        # type: () -> Iterator[Package]
+        for pkgname in self._helper._filtered:
+            yield self.cache[pkgname]
+
+    def keys(self):
+        # type: () -> KeysView[str]
+        return self._helper._filtered.keys()
+
+    def has_key(self, key):
+        # type: (object) -> bool
+        return key in self
+
+    def __contains__(self, key):
+        # type: (object) -> bool
+        try:
+            # Normalize package name for multi arch
+            return self.cache[key].name in self._helper._filtered
+        except KeyError:
+            return False
+
+    def set_filter(self, filter):
+        # type: (Filter) -> None
+        """Set the current active filter."""
+        self._helper.set_filter(filter)
+        self.cache.cache_post_change()
+
+    def filter_cache_post_change(self):
+        # type: () -> None
+        """Called internally if the cache changes, emit a signal then."""
+        self._helper.filter_cache_post_change(self.cache)
+
+    def __getattr__(self, key):
+        # type: (str) -> Any
+        """we try to look exactly like a real cache."""
+        return getattr(self.cache, key)
+
+
+def cache_pre_changed(cache):
+    # type: (Cache) -> None
+    print("cache pre changed")
+
+
+def cache_post_changed(cache):
+    # type: (Cache) -> None
+    print("cache post changed")
+
+
+def _test():
+    # type: () -> None
+    """Internal test code."""
+    print("Cache self test")
+    apt_pkg.init()
+    cache = Cache(apt.progress.text.OpProgress())
+    cache.connect2("cache_pre_change", cache_pre_changed)
+    cache.connect2("cache_post_change", cache_post_changed)
+    print(("aptitude" in cache))
+    pkg = cache["aptitude"]
+    print(pkg.name)
+    print(len(cache))
+
+    for pkgname in cache.keys():
+        assert cache[pkgname].name == pkgname
+
+    cache.upgrade()
+    changes = cache.get_changes()
+    print(len(changes))
+    for pkg in changes:
+        assert pkg.name
+
+    # see if fetching works
+    for dirname in ["/tmp/pytest", "/tmp/pytest/partial"]:
+        if not os.path.exists(dirname):
+            os.mkdir(dirname)
+    apt_pkg.config.set("Dir::Cache::Archives", "/tmp/pytest")
+    pm = apt_pkg.PackageManager(cache._depcache)
+    fetcher = apt_pkg.Acquire(apt.progress.text.AcquireProgress())
+    cache._fetch_archives(fetcher, pm, None)
+    #sys.exit(1)
+
+    print("Testing filtered cache (argument is old cache)")
+    filtered = FilteredCache(cache)
+    filtered.cache.connect2("cache_pre_change", cache_pre_changed)
+    filtered.cache.connect2("cache_post_change", cache_post_changed)
+    filtered.cache.upgrade()
+    filtered.set_filter(MarkedChangesFilter())
+    print(len(filtered))
+    for pkgname in filtered.keys():
+        assert pkgname == filtered[pkgname].name
+
+    print(len(filtered))
+
+    print("Testing filtered cache (no argument)")
+    filtered = FilteredCache(progress=apt.progress.base.OpProgress())
+    filtered.cache.connect2("cache_pre_change", cache_pre_changed)
+    filtered.cache.connect2("cache_post_change", cache_post_changed)
+    filtered.cache.upgrade()
+    filtered.set_filter(MarkedChangesFilter())
+    print(len(filtered))
+    for pkgname in filtered.keys():
+        assert pkgname == filtered[pkgname].name
+
+    print(len(filtered))
+
+
+if __name__ == '__main__':
+    _test()

build/lib.linux-x86_64-cpython-310/apt/cdrom.py

@@ -0,0 +1,92 @@
+# cdrom.py - CDROM handling
+#
+#  Copyright (c) 2005-2009 Canonical
+#  Copyright (c) 2009 Julian Andres Klode <[email protected]>
+#
+#  Author: Michael Vogt <[email protected]>
+#
+#  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 related to cdrom handling."""
+from __future__ import print_function
+
+from typing import Optional
+import glob
+
+import apt_pkg
+from apt.progress.base import CdromProgress
+
+
+class Cdrom(apt_pkg.Cdrom):
+    """Support for apt-cdrom like features.
+
+    This class has several optional parameters for initialisation, which may
+    be used to influence the behaviour of the object:
+
+    The optional parameter `progress` is a CdromProgress() subclass, which will
+    ask for the correct cdrom, etc. If not specified or None, a CdromProgress()
+    object will be used.
+
+    The optional parameter `mountpoint` may be used to specify an alternative
+    mountpoint.
+
+    If the optional parameter `nomount` is True, the cdroms will not be
+    mounted. This is the default behaviour.
+    """
+
+    def __init__(self, progress=None, mountpoint=None, nomount=True):
+        # type: (Optional[CdromProgress], Optional[str], bool) -> None
+        apt_pkg.Cdrom.__init__(self)
+        if progress is None:
+            self._progress = CdromProgress()
+        else:
+            self._progress = progress
+        # see if we have a alternative mountpoint
+        if mountpoint is not None:
+            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")
+        else:
+            apt_pkg.config.set("APT::CDROM::NoMount", "false")
+
+    def add(self, progress=None):
+        # type: (Optional[CdromProgress]) -> bool
+        """Add cdrom to the sources.list."""
+        return apt_pkg.Cdrom.add(self, progress or self._progress)
+
+    def ident(self, progress=None):
+        # type: (Optional[CdromProgress]) -> str
+        """Identify the cdrom."""
+        return apt_pkg.Cdrom.ident(self, progress or self._progress)
+
+    @property
+    def in_sources_list(self):
+        # type: () -> bool
+        """Check if the cdrom is already in the current sources.list."""
+        cd_id = self.ident()
+        if cd_id is None:
+            # FIXME: throw exception instead
+            return False
+        # Get a list of files
+        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:
+            with open(fname) as fobj:
+                for line in fobj:
+                    if not line.lstrip().startswith("#") and cd_id in line:
+                        return True
+        return False

build/lib.linux-x86_64-cpython-310/apt/debfile.py

@@ -0,0 +1,868 @@
+#  Copyright (c) 2005-2010 Canonical
+#
+#  Author: Michael Vogt <[email protected]>
+#
+#  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 for working with locally available Debian packages."""
+from __future__ import print_function
+
+import apt
+import apt_inst
+import apt_pkg
+import gzip
+import os
+import sys
+
+from typing import Dict, Iterable, List, Optional, Set, Tuple, Union, cast
+
+from apt_pkg import gettext as _
+from io import BytesIO
+
+
+class NoDebArchiveException(IOError):
+    """Exception which is raised if a file is no Debian archive."""
+
+
+class DebPackage(object):
+    """A Debian Package (.deb file)."""
+
+    # Constants for comparing the local package file with the version
+    # in the cache
+    (VERSION_NONE,
+     VERSION_OUTDATED,
+     VERSION_SAME,
+     VERSION_NEWER) = range(4)
+
+    debug = 0
+
+    def __init__(self, filename=None, cache=None):
+        # type: (Optional[str], Optional[apt.Cache]) -> None
+        if cache is None:
+            cache = apt.Cache()
+        self._cache = cache
+        self._debfile = cast(apt_inst.DebFile, None)
+        self.pkgname = ""
+        self.filename = None  # type: Optional[str]
+        self._sections = {}  # type: Union[Dict[str, str], apt_pkg.TagSection[str]]  # noqa
+        self._need_pkgs = []  # type: List[str]
+        self._check_was_run = False
+        self._failure_string = ""
+        self._multiarch = None  # type: Optional[str]
+        if filename:
+            self.open(filename)
+
+    def open(self, filename):
+        # type: (str) -> None
+        """ open given debfile """
+        self._dbg(3, "open '%s'" % filename)
+        self._need_pkgs = []
+        self._installed_conflicts = set()  # type: Set[str]
+        self._failure_string = ""
+        self.filename = 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"]
+        self._check_was_run = False
+
+    def __getitem__(self, key):
+        # type: (str) -> str
+        return self._sections[key]
+
+    def __contains__(self, key):
+        # type: (str) -> bool
+        return key in self._sections
+
+    @property
+    def filelist(self):
+        # type: () -> List[str]
+        """return the list of files in the deb."""
+        files = []
+        try:
+            self._debfile.data.go(lambda item, data: files.append(item.name))
+        except SystemError:
+            return [_("List of files for '%s' could not be read") %
+                    self.filename]
+        return files
+
+    @property
+    def control_filelist(self):
+        # type: () -> List[str]
+        """ return the list of files in control.tar.gz """
+        control = []
+        try:
+            self._debfile.control.go(
+                lambda item, data: control.append(item.name))
+        except SystemError:
+            return [_("List of control files for '%s' could not be read") %
+                    self.filename]
+        return sorted(control)
+
+    # helper that will return a pkgname with a multiarch suffix if needed
+    def _maybe_append_multiarch_suffix(self, pkgname,
+                                       in_conflict_checking=False):
+        # type: (str, bool) -> str
+        # trivial cases
+        if ":" in pkgname:
+            return pkgname
+        if not self._multiarch:
+            return pkgname
+        elif self._cache.is_virtual_package(pkgname):
+            return pkgname
+        elif (pkgname in self._cache and
+              self._cache[pkgname].candidate is not None and
+              cast(apt.package.Version,
+                   self._cache[pkgname].candidate).architecture == "all"):
+            return pkgname
+        # now do the real multiarch checking
+        multiarch_pkgname = "%s:%s" % (pkgname, self._multiarch)
+        # the upper layers will handle this
+        if multiarch_pkgname not in self._cache:
+            return multiarch_pkgname
+        multiarch_pkg = self._cache[multiarch_pkgname]
+        if multiarch_pkg.candidate is None:
+            return multiarch_pkgname
+        # now check the multiarch state
+        cand = multiarch_pkg.candidate._cand
+        #print pkgname, multiarch_pkgname, cand.multi_arch
+        # the default is to add the suffix, unless its a pkg that can satify
+        # foreign dependencies
+        if cand.multi_arch & cand.MULTI_ARCH_FOREIGN:
+            return pkgname
+        # for conflicts we need a special case here, any not multiarch enabled
+        # package has a implicit conflict
+        if (in_conflict_checking and
+                not (cand.multi_arch & cand.MULTI_ARCH_SAME)):
+            return pkgname
+        return multiarch_pkgname
+
+    def _is_or_group_satisfied(self, or_group):
+        # type: (List[Tuple[str, str, str]]) -> bool
+        """Return True if at least one dependency of the or-group is satisfied.
+
+        This method gets an 'or_group' and analyzes if at least one dependency
+        of this group is already satisfied.
+        """
+        self._dbg(2, "_checkOrGroup(): %s " % (or_group))
+
+        for dep in or_group:
+            depname = dep[0]
+            ver = dep[1]
+            oper = dep[2]
+
+            # multiarch
+            depname = self._maybe_append_multiarch_suffix(depname)
+
+            # check for virtual pkgs
+            if depname not in self._cache:
+                if self._cache.is_virtual_package(depname):
+                    self._dbg(
+                        3, "_is_or_group_satisfied(): %s is virtual dep" %
+                        depname)
+                    for pkg in self._cache.get_providing_packages(depname):
+                        if pkg.is_installed:
+                            return True
+                continue
+            # check real dependency
+            inst = self._cache[depname].installed
+            if inst is not None and apt_pkg.check_dep(inst.version, oper, ver):
+                return True
+
+            # if no real dependency is installed, check if there is
+            # a package installed that provides this dependency
+            # (e.g. scrollkeeper dependecies are provided by rarian-compat)
+            # but only do that if there is no version required in the
+            # dependency (we do not supprot versionized dependencies)
+            if not oper:
+                for ppkg in self._cache.get_providing_packages(
+                    depname, include_nonvirtual=True):
+                    if ppkg.is_installed:
+                        self._dbg(
+                            3, "found installed '%s' that provides '%s'" % (
+                                ppkg.name, depname))
+                        return True
+        return False
+
+    def _satisfy_or_group(self, or_group):
+        # type: (List[Tuple[str, str, str]]) -> bool
+        """Try to satisfy the or_group."""
+        for dep in or_group:
+            depname, ver, oper = dep
+
+            # multiarch
+            depname = self._maybe_append_multiarch_suffix(depname)
+
+            # if we don't have it in the cache, it may be virtual
+            if depname not in self._cache:
+                if not self._cache.is_virtual_package(depname):
+                    continue
+                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:
+                    continue
+                depname = providers[0].name
+
+            # now check if we can satisfy the deps with the candidate(s)
+            # in the cache
+            pkg = self._cache[depname]
+            cand = self._cache._depcache.get_candidate_ver(pkg._pkg)
+            if not cand:
+                continue
+            if not apt_pkg.check_dep(cand.ver_str, oper, ver):
+                continue
+
+            # check if we need to install it
+            self._dbg(2, "Need to get: %s" % depname)
+            self._need_pkgs.append(depname)
+            return True
+
+        # if we reach this point, we failed
+        or_str = ""
+        for dep in or_group:
+            or_str += dep[0]
+            if ver and oper:
+                or_str += " (%s %s)" % (dep[2], dep[1])
+            if dep != or_group[len(or_group) - 1]:
+                or_str += "|"
+        self._failure_string += _(
+            "Dependency is not satisfiable: %s\n") % or_str
+        return False
+
+    def _check_single_pkg_conflict(self, pkgname, ver, oper):
+        # type: (str, str, str) -> bool
+        """Return True if a pkg conflicts with a real installed/marked pkg."""
+        # FIXME: deal with conflicts against its own provides
+        #        (e.g. Provides: ftp-server, Conflicts: ftp-server)
+        self._dbg(
+            3, "_check_single_pkg_conflict() pkg='%s' ver='%s' oper='%s'" % (
+                pkgname, ver, oper))
+        pkg = self._cache[pkgname]
+        if pkg.is_installed:
+            assert pkg.installed is not None
+            pkgver = pkg.installed.version
+        elif pkg.marked_install:
+            assert pkg.candidate is not None
+            pkgver = pkg.candidate.version
+        else:
+            return False
+        #print "pkg: %s" % pkgname
+        #print "ver: %s" % ver
+        #print "pkgver: %s " % pkgver
+        #print "oper: %s " % oper
+        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
+            self._dbg(3, "conflicts with installed pkg '%s'" % pkg.name)
+            return True
+        return False
+
+    def _check_conflicts_or_group(self, or_group):
+        # type: (List[Tuple[str, str, str]]) -> bool
+        """Check the or-group for conflicts with installed pkgs."""
+        self._dbg(2, "_check_conflicts_or_group(): %s " % (or_group))
+        for dep in or_group:
+            depname = dep[0]
+            ver = dep[1]
+            oper = dep[2]
+
+            # FIXME: is this good enough? i.e. will apt always populate
+            #        the cache with conflicting pkgnames for our arch?
+            depname = self._maybe_append_multiarch_suffix(
+                depname, in_conflict_checking=True)
+
+            # check conflicts with virtual pkgs
+            if depname not in self._cache:
+                # FIXME: we have to check for virtual replaces here as
+                #        well (to pass tests/gdebi-test8.deb)
+                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:
+                            self._dbg(3, "conflict on self, ignoring")
+                            continue
+                        if self._check_single_pkg_conflict(
+                                pkg.name, ver, oper):
+                            self._installed_conflicts.add(pkg.name)
+                continue
+            if self._check_single_pkg_conflict(depname, ver, oper):
+                self._installed_conflicts.add(depname)
+        return bool(self._installed_conflicts)
+
+    @property
+    def conflicts(self):
+        # type: () -> List[List[Tuple[str, str, str]]]
+        """List of packages conflicting with this package."""
+        key = "Conflicts"
+        try:
+            return apt_pkg.parse_depends(self._sections[key], False)
+        except KeyError:
+            return []
+
+    @property
+    def depends(self):
+        # type: () -> List[List[Tuple[str, str, str]]]
+        """List of packages on which this package depends on."""
+        depends = []
+        # find depends
+        for key in "Depends", "Pre-Depends":
+            try:
+                depends.extend(
+                    apt_pkg.parse_depends(self._sections[key], False))
+            except KeyError:
+                pass
+        return depends
+
+    @property
+    def provides(self):
+        # type: () -> List[List[Tuple[str, str, str]]]
+        """List of virtual packages which are provided by this package."""
+        key = "Provides"
+        try:
+            return apt_pkg.parse_depends(self._sections[key], False)
+        except KeyError:
+            return []
+
+    @property
+    def replaces(self):
+        # type: () -> List[List[Tuple[str, str, str]]]
+        """List of packages which are replaced by this package."""
+        key = "Replaces"
+        try:
+            return apt_pkg.parse_depends(self._sections[key], False)
+        except KeyError:
+            return []
+
+    def replaces_real_pkg(self, pkgname, oper, ver):
+        # type: (str, str, str) -> bool
+        """Return True if a given non-virtual package is replaced.
+
+        Return True if the deb packages replaces a real (not virtual)
+        packages named (pkgname, oper, ver).
+        """
+        self._dbg(3, "replaces_real_pkg() %s %s %s" % (pkgname, oper, ver))
+        pkg = self._cache[pkgname]
+        pkgver = None  # type: Optional[str]
+        if pkg.is_installed:
+            assert pkg.installed is not None
+            pkgver = pkg.installed.version
+        elif pkg.marked_install:
+            assert pkg.candidate is not None
+            pkgver = pkg.candidate.version
+        else:
+            pkgver = None
+        for or_group in self.replaces:
+            for (name, ver, oper) in or_group:
+                if (name == pkgname and (pkgver is None or
+                        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
+        return False
+
+    def check_conflicts(self):
+        # type: () -> bool
+        """Check if there are conflicts with existing or selected packages.
+
+        Check if the package conflicts with a existing or to be installed
+        package. Return True if the pkg is OK.
+        """
+        res = True
+        for or_group in self.conflicts:
+            if self._check_conflicts_or_group(or_group):
+                #print "Conflicts with a exisiting pkg!"
+                #self._failure_string = "Conflicts with a exisiting pkg!"
+                res = False
+        return res
+
+    def check_breaks_existing_packages(self):
+        # type: () -> bool
+        """
+        check if installing the package would break exsisting
+        package on the system, e.g. system has:
+        smc depends on smc-data (= 1.4)
+        and user tries to installs smc-data 1.6
+        """
+        # show progress information as this step may take some time
+        size = float(len(self._cache))
+        steps = max(int(size / 50), 1)
+        debver = self._sections["Version"]
+        debarch = self._sections["Architecture"]
+        # store what we provide so that we can later check against that
+        provides = [x[0][0] for x in self.provides]
+        for (i, pkg) in enumerate(self._cache):
+            if i % steps == 0:
+                self._cache.op_progress.update(float(i) / size * 100.0)
+            if not pkg.is_installed:
+                continue
+            assert pkg.installed is not None
+            # check if the exising dependencies are still satisfied
+            # with the package
+            ver = pkg._pkg.current_ver
+            for dep_or in pkg.installed.dependencies:
+                for dep in dep_or.or_dependencies:
+                    if dep.name == self.pkgname:
+                        if not apt_pkg.check_dep(
+                                debver, dep.relation, dep.version):
+                            self._dbg(2, "would break (depends) %s" % pkg.name)
+                            # TRANSLATORS: the first '%s' is the package that
+                            # breaks, the second the dependency that makes it
+                            # break, the third the relation (e.g. >=) and the
+                            # latest the version for the releation
+                            self._failure_string += _(
+                                "Breaks existing package '%(pkgname)s' "
+                                "dependency %(depname)s "
+                                "(%(deprelation)s %(depversion)s)") % {
+                                    'pkgname': pkg.name,
+                                    'depname': dep.name,
+                                    'deprelation': dep.relation,
+                                    'depversion': dep.version}
+                            self._cache.op_progress.done()
+                            return False
+            # now check if there are conflicts against this package on
+            # the existing system
+            if "Conflicts" in ver.depends_list:
+                for conflicts_ver_list in ver.depends_list["Conflicts"]:
+                    for c_or in conflicts_ver_list:
+                        if (c_or.target_pkg.name == self.pkgname and
+                                c_or.target_pkg.architecture == debarch):
+                            if apt_pkg.check_dep(
+                                    debver, c_or.comp_type, c_or.target_ver):
+                                self._dbg(
+                                    2, "would break (conflicts) %s" % pkg.name)
+                                # TRANSLATORS: the first '%s' is the package
+                                # that conflicts, the second the packagename
+                                # that it conflicts with (so the name of the
+                                # deb the user tries to install), the third is
+                                # the relation (e.g. >=) and the last is the
+                                # version for the relation
+                                self._failure_string += _(
+                                    "Breaks existing package '%(pkgname)s' "
+                                    "conflict: %(targetpkg)s "
+                                    "(%(comptype)s %(targetver)s)") % {
+                                        'pkgname': pkg.name,
+                                        'targetpkg': c_or.target_pkg.name,
+                                        'comptype': c_or.comp_type,
+                                        'targetver': c_or.target_ver}
+                                self._cache.op_progress.done()
+                                return False
+                        if (c_or.target_pkg.name in provides and
+                                self.pkgname != pkg.name):
+                            self._dbg(
+                                2, "would break (conflicts) %s" % provides)
+                            self._failure_string += _(
+                                "Breaks existing package '%(pkgname)s' "
+                                "that conflict: '%(targetpkg)s'. But the "
+                                "'%(debfile)s' provides it via: "
+                                "'%(provides)s'") % {
+                                    'provides': ",".join(provides),
+                                    'debfile': self.filename,
+                                    'targetpkg': c_or.target_pkg.name,
+                                    'pkgname': pkg.name}
+                            self._cache.op_progress.done()
+                            return False
+        self._cache.op_progress.done()
+        return True
+
+    def compare_to_version_in_cache(self, use_installed=True):
+        # type: (bool) -> int
+        """Compare the package to the version available in the cache.
+
+        Checks if the package is already installed or availabe in the cache
+        and if so in what version, returns one of (VERSION_NONE,
+        VERSION_OUTDATED, VERSION_SAME, VERSION_NEWER).
+        """
+        self._dbg(3, "compare_to_version_in_cache")
+        pkgname = self._sections["Package"]
+        architecture = self._sections["Architecture"]
+
+        # Arch qualify the package name
+        pkgname = ":".join([pkgname, architecture])
+
+        debver = self._sections["Version"]
+        self._dbg(1, "debver: %s" % debver)
+        if pkgname in self._cache:
+            pkg = self._cache[pkgname]
+            if use_installed and pkg.installed is not None:
+                cachever = pkg.installed.version
+            elif not use_installed and pkg.candidate is not None:
+                cachever = pkg.candidate.version
+            else:
+                return self.VERSION_NONE
+            if cachever is not None:
+                cmp = apt_pkg.version_compare(cachever, debver)
+                self._dbg(1, "CompareVersion(debver,instver): %s" % cmp)
+                if cmp == 0:
+                    return self.VERSION_SAME
+                elif cmp < 0:
+                    return self.VERSION_NEWER
+                elif cmp > 0:
+                    return self.VERSION_OUTDATED
+        return self.VERSION_NONE
+
+    def check(self, allow_downgrade=False):
+        # type: (bool) -> bool
+        """Check if the package is installable."""
+        self._dbg(3, "check")
+
+        self._check_was_run = True
+
+        # check arch
+        if "Architecture" not in self._sections:
+            self._dbg(1, "ERROR: no architecture field")
+            self._failure_string = _("No Architecture field in the package")
+            return False
+        arch = self._sections["Architecture"]
+        if arch != "all" and arch != apt_pkg.config.find("APT::Architecture"):
+            if arch in apt_pkg.get_architectures():
+                self._multiarch = arch
+                self.pkgname = "%s:%s" % (self.pkgname, self._multiarch)
+                self._dbg(1, "Found multiarch arch: '%s'" % arch)
+            else:
+                self._dbg(1, "ERROR: Wrong architecture dude!")
+                self._failure_string = _("Wrong architecture '%s' "
+                                         "-- Run dpkg --add-architecture to "
+                                         "add it and update afterwards") % arch
+                return False
+
+        # check version
+        if (not allow_downgrade and
+            self.compare_to_version_in_cache() == self.VERSION_OUTDATED):
+            if self._cache[self.pkgname].installed:
+                # the deb is older than the installed
+                self._failure_string = _(
+                    "A later version is already installed")
+                return False
+
+        # FIXME: this sort of error handling sux
+        self._failure_string = ""
+
+        # check conflicts
+        if not self.check_conflicts():
+            return False
+
+        # check if installing it would break anything on the
+        # current system
+        if not self.check_breaks_existing_packages():
+            return False
+
+        # try to satisfy the dependencies
+        if not self._satisfy_depends(self.depends):
+            return False
+
+        # check for conflicts again (this time with the packages that are
+        # makeed for install)
+        if not self.check_conflicts():
+            return False
+
+        if self._cache._depcache.broken_count > 0:
+            self._failure_string = _("Failed to satisfy all dependencies "
+                                     "(broken cache)")
+            # clean the cache again
+            self._cache.clear()
+            return False
+        return True
+
+    def satisfy_depends_str(self, dependsstr):
+        # type: (str) -> bool
+        """Satisfy the dependencies in the given string."""
+        return self._satisfy_depends(apt_pkg.parse_depends(dependsstr, False))
+
+    def _satisfy_depends(self, depends):
+        # type: (List[List[Tuple[str, str, str]]]) -> bool
+        """Satisfy the dependencies."""
+        # turn off MarkAndSweep via a action group (if available)
+        try:
+            _actiongroup = apt_pkg.ActionGroup(self._cache._depcache)
+            _actiongroup  # pyflakes
+        except AttributeError:
+            pass
+        # check depends
+        for or_group in depends:
+            if not self._is_or_group_satisfied(or_group):
+                if not self._satisfy_or_group(or_group):
+                    return False
+        # now try it out in the cache
+        for pkg in self._need_pkgs:
+            try:
+                self._cache[pkg].mark_install(from_user=False)
+            except SystemError:
+                self._failure_string = _("Cannot install '%s'") % pkg
+                self._cache.clear()
+                return False
+        return True
+
+    @property
+    def missing_deps(self):
+        # type: () -> List[str]
+        """Return missing dependencies."""
+        self._dbg(1, "Installing: %s" % self._need_pkgs)
+        if not self._check_was_run:
+            raise AttributeError(
+                "property only available after check() was run")
+        return self._need_pkgs
+
+    @property
+    def required_changes(self):
+        # type: () -> Tuple[List[str], List[str], List[str]]
+        """Get the changes required to satisfy the dependencies.
+
+        Returns: a tuple with (install, remove, unauthenticated)
+        """
+        install = []
+        remove = []
+        unauthenticated = []
+        if not self._check_was_run:
+            raise AttributeError(
+                "property only available after check() was run")
+        for pkg in self._cache:
+            if pkg.marked_install or pkg.marked_upgrade:
+                assert pkg.candidate is not None
+                install.append(pkg.name)
+                # check authentication, one authenticated origin is enough
+                # libapt will skip non-authenticated origins then
+                authenticated = False
+                for origin in pkg.candidate.origins:
+                    authenticated |= origin.trusted
+                if not authenticated:
+                    unauthenticated.append(pkg.name)
+            if pkg.marked_delete:
+                remove.append(pkg.name)
+        return (install, remove, unauthenticated)
+
+    @staticmethod
+    def to_hex(in_data):
+        # type: (str) -> str
+        hex = ""
+        for (i, c) in enumerate(in_data):
+            if i % 80 == 0:
+                hex += "\n"
+            hex += "%2.2x " % ord(c)
+        return hex
+
+    @staticmethod
+    def to_strish(in_data):
+        # type: (Union[str, Iterable[int]]) -> str
+        s = ""
+        # py2 compat, in_data is type string
+        if isinstance(in_data, str):
+            for c in in_data:
+                if ord(c) < 10 or ord(c) > 127:
+                    s += " "
+                else:
+                    s += c
+        # py3 compat, in_data is type bytes
+        else:
+            for b in in_data:
+                if b < 10 or b > 127:
+                    s += " "
+                else:
+                    s += chr(b)
+        return s
+
+    def _get_content(self, part, name, auto_decompress=True, auto_hex=True):
+        # type: (apt_inst.TarFile, str, bool, bool) -> str
+        if name.startswith("./"):
+            name = name[2:]
+        data = part.extractdata(name)
+        # check for zip content
+        if name.endswith(".gz") and auto_decompress:
+            io = BytesIO(data)
+            gz = gzip.GzipFile(fileobj=io)
+            data = _("Automatically decompressed:\n\n").encode("utf-8")
+            data += gz.read()
+        # auto-convert to hex
+        try:
+            return data.decode("utf-8")
+        except Exception:
+            new_data = _("Automatically converted to printable ascii:\n")
+            new_data += self.to_strish(data)
+            return new_data
+
+    def control_content(self, name):
+        # type: (str) -> str
+        """ return the content of a specific control.tar.gz file """
+        try:
+            return self._get_content(self._debfile.control, name)
+        except LookupError:
+            return ""
+
+    def data_content(self, name):
+        # type: (str) -> str
+        """ return the content of a specific control.tar.gz file """
+        try:
+            return self._get_content(self._debfile.data, name)
+        except LookupError:
+            return ""
+
+    def _dbg(self, level, msg):
+        # type: (int, str) -> None
+        """Write debugging output to sys.stderr."""
+        if level <= self.debug:
+            print(msg, file=sys.stderr)
+
+    def install(self, install_progress=None):
+        # type: (Optional[apt.progress.base.InstallProgress]) -> int
+        """Install the package."""
+        if self.filename is None:
+            raise apt_pkg.Error("No filename specified")
+        if install_progress is None:
+            return os.spawnlp(os.P_WAIT, "dpkg", "dpkg", "-i", self.filename)
+        else:
+            try:
+                install_progress.start_update()
+            except AttributeError:
+                install_progress.startUpdate()  # type: ignore
+            res = install_progress.run(self.filename)
+            try:
+                install_progress.finish_update()
+            except AttributeError:
+                install_progress.finishUpdate()  # type: ignore
+            return res
+
+
+class DscSrcPackage(DebPackage):
+    """A locally available source package."""
+
+    def __init__(self, filename=None, cache=None):
+        # type: (Optional[str], Optional[apt.Cache]) -> None
+        DebPackage.__init__(self, None, cache)
+        self.filename = filename  # type: Optional[str]
+        self._depends = []  # type: List[List[Tuple[str, str, str]]]
+        self._conflicts = []  # type: List[List[Tuple[str, str, str]]]
+        self._installed_conflicts = set()  # type: Set[str]
+        self.pkgname = ""
+        self.binaries = []  # type: List[str]
+        self._sections = {}  # type: Dict[str, str]
+        if self.filename is not None:
+            self.open(self.filename)
+
+    @property
+    def depends(self):
+        # type: () -> List[List[Tuple[str, str, str]]]
+        """Return the dependencies of the package"""
+        return self._depends
+
+    @property
+    def conflicts(self):
+        # type: () -> List[List[Tuple[str, str, str]]]
+        """Return the dependencies of the package"""
+        return self._conflicts
+
+    @property
+    def filelist(self):
+        # type: () -> List[str]
+        """Return the list of files associated with this dsc file"""
+        # Files stanza looks like (hash, size, filename, ...)
+        return self._sections['Files'].split()[2::3]
+
+    def open(self, file):
+        # type: (str) -> None
+        """Open the package."""
+        depends_tags = ["Build-Depends", "Build-Depends-Indep"]
+        conflicts_tags = ["Build-Conflicts", "Build-Conflicts-Indep"]
+        fd = apt_pkg.open_maybe_clear_signed_file(file)
+        fobj = os.fdopen(fd)
+        tagfile = apt_pkg.TagFile(fobj)
+        try:
+            for sec in tagfile:
+                for tag in depends_tags:
+                    if tag not in sec:
+                        continue
+                    self._depends.extend(apt_pkg.parse_src_depends(sec[tag]))
+                for tag in conflicts_tags:
+                    if tag not in sec:
+                        continue
+                    self._conflicts.extend(apt_pkg.parse_src_depends(sec[tag]))
+                if 'Source' in sec:
+                    self.pkgname = sec['Source']
+                if 'Binary' in sec:
+                    self.binaries = [b.strip() for b in
+                                     sec['Binary'].split(',')]
+                for tag in sec.keys():
+                    if tag in sec:
+                        self._sections[tag] = sec[tag]
+        finally:
+            del tagfile
+            fobj.close()
+
+        s = _("Install Build-Dependencies for "
+              "source package '%s' that builds %s\n") % (self.pkgname,
+              " ".join(self.binaries))
+        self._sections["Description"] = s
+        self._check_was_run = False
+
+    def check(self, allow_downgrade=False):
+        # type: (bool) -> bool
+        """Check if the package is installable.
+
+        The second parameter is ignored and only exists for compatibility
+        with parent type."""
+        if not self.check_conflicts():
+            for pkgname in self._installed_conflicts:
+                if self._cache[pkgname]._pkg.essential:
+                    raise Exception(_("An essential package would be removed"))
+                self._cache[pkgname].mark_delete()
+        # properties are ok now
+        self._check_was_run = True
+        # FIXME: a additional run of the check_conflicts()
+        #        after _satisfy_depends() should probably be done
+        return self._satisfy_depends(self.depends)
+
+
+def _test():
+    # type: () -> None
+    """Test function"""
+    from apt.cache import Cache
+    from apt.progress.base import InstallProgress
+
+    cache = Cache()
+
+    vp = "www-browser"
+    print("%s virtual: %s" % (vp, cache.is_virtual_package(vp)))
+    providers = cache.get_providing_packages(vp)
+    print("Providers for %s :" % vp)
+    for pkg in providers:
+        print(" %s" % pkg.name)
+
+    d = DebPackage(sys.argv[1], cache)
+    print("Deb: %s" % d.pkgname)
+    if not d.check():
+        print("can't be satified")
+        print(d._failure_string)
+    print("missing deps: %s" % d.missing_deps)
+    print(d.required_changes)
+
+    print(d.filelist)
+
+    print("Installing ...")
+    ret = d.install(InstallProgress())
+    print(ret)
+
+    #s = DscSrcPackage(cache, "../tests/3ddesktop_0.2.9-6.dsc")
+    #s.check_dep()
+    #print "Missing deps: ",s.missingDeps
+    #print "Print required changes: ", s.requiredChanges
+
+    s = DscSrcPackage(cache=cache)
+    ds = "libc6 (>= 2.3.2), libaio (>= 0.3.96) | libaio1 (>= 0.3.96)"
+    print(s._satisfy_depends(apt_pkg.parse_depends(ds, False)))
+
+
+if __name__ == "__main__":
+    _test()

build/lib.linux-x86_64-cpython-310/apt/package.py

@@ -0,0 +1,1604 @@
+# package.py - apt package abstraction
+#
+#  Copyright (c) 2005-2009 Canonical
+#
+#  Author: Michael Vogt <[email protected]>
+#
+#  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
+"""Functionality related to packages."""
+from __future__ import print_function
+
+import logging
+import os
+import sys
+import re
+import socket
+import subprocess
+import threading
+
+from http.client import BadStatusLine
+from urllib.error import HTTPError
+from urllib.request import urlopen
+
+from typing import (Any, Iterable, Iterator, List, Optional, Set,
+                    Tuple, Union, no_type_check, Mapping,
+                    Sequence)
+
+import apt_pkg
+import apt.progress.text
+
+from apt.progress.base import (
+    AcquireProgress,
+    InstallProgress,
+)
+
+from apt_pkg import gettext as _
+
+__all__ = ('BaseDependency', 'Dependency', 'Origin', 'Package', 'Record',
+           'Version', 'VersionList')
+
+
+def _file_is_same(path, size, hashes):
+    # type: (str, int, apt_pkg.HashStringList) -> bool
+    """Return ``True`` if the file is the same."""
+    if os.path.exists(path) and os.path.getsize(path) == size:
+        with open(path) as fobj:
+            return apt_pkg.Hashes(fobj).hashes == hashes
+    return False
+
+
+class FetchError(Exception):
+    """Raised when a file could not be fetched."""
+
+
+class UntrustedError(FetchError):
+    """Raised when a file did not have a trusted hash."""
+
+
+class BaseDependency(object):
+    """A single dependency."""
+
+    class __dstr(str):
+        """Compare helper for compatibility with old third-party code.
+
+        Old third-party code might still compare the relation with the
+        previously used relations (<<,<=,==,!=,>=,>>,) instead of the curently
+        used ones (<,<=,=,!=,>=,>,). This compare helper lets < match to <<,
+        > match to >> and = match to ==.
+        """
+
+        def __eq__(self, other):
+            # type: (object) -> bool
+            if str.__eq__(self, other):
+                return True
+            elif str.__eq__(self, '<'):
+                return str.__eq__('<<', other)
+            elif str.__eq__(self, '>'):
+                return str.__eq__('>>', other)
+            elif str.__eq__(self, '='):
+                return str.__eq__('==', other)
+            else:
+                return False
+
+        def __ne__(self, other):
+            # type: (object) -> bool
+            return not self.__eq__(other)
+
+    def __init__(self, version, dep):
+        # type: (Version, apt_pkg.Dependency) -> None
+        self._version = version  # apt.package.Version
+        self._dep = dep  # apt_pkg.Dependency
+
+    def __str__(self):
+        # type: () -> str
+        return '%s: %s' % (self.rawtype, self.rawstr)
+
+    def __repr__(self):
+        # type: () -> str
+        return ('<BaseDependency: name:%r relation:%r version:%r rawtype:%r>'
+                % (self.name, self.relation, self.version, self.rawtype))
+
+    @property
+    def name(self):
+        # type: () -> str
+        """The name of the target package."""
+        return self._dep.target_pkg.name
+
+    @property
+    def relation(self):
+        # type: () -> str
+        """The relation (<, <=, =, !=, >=, >, '') in mathematical notation.
+
+        The empty string will be returned in case of an unversioned dependency.
+        """
+        return self.__dstr(self._dep.comp_type)
+
+    @property
+    def relation_deb(self):
+        # type: () -> str
+        """The relation (<<, <=, =, !=, >=, >>, '') in Debian notation.
+
+        The empty string will be returned in case of an unversioned dependency.
+        For more details see the Debian Policy Manual on the syntax of
+        relationship fields:
+        https://www.debian.org/doc/debian-policy/ch-relationships.html#s-depsyntax  # noqa
+
+        .. versionadded:: 1.0.0
+        """
+        return self._dep.comp_type_deb
+
+    @property
+    def version(self):
+        # type: () -> str
+        """The target version or an empty string.
+
+        Note that the version is only an empty string in case of an unversioned
+        dependency. In this case the relation is also an empty string.
+        """
+        return self._dep.target_ver
+
+    @property
+    def target_versions(self):
+        # type: () -> List[Version]
+        """A list of all Version objects which satisfy this dependency.
+
+        .. versionadded:: 1.0.0
+        """
+        tvers = []
+        _tvers = self._dep.all_targets()  # type: List[apt_pkg.Version]
+        for _tver in _tvers:  # type: apt_pkg.Version
+            _pkg = _tver.parent_pkg  # type: apt_pkg.Package
+            cache = self._version.package._pcache  # apt.cache.Cache
+            pkg = cache._rawpkg_to_pkg(_pkg)  # apt.package.Package
+            tver = Version(pkg, _tver)  # apt.package.Version
+            tvers.append(tver)
+        return tvers
+
+    @property
+    def installed_target_versions(self):
+        # type: () -> List[Version]
+        """A list of all installed Version objects which satisfy this dep.
+
+        .. versionadded:: 1.0.0
+        """
+        return [tver for tver in self.target_versions if tver.is_installed]
+
+    @property
+    def rawstr(self):
+        # type: () -> str
+        """String represenation of the dependency.
+
+        Returns the string representation of the dependency as it would be
+        written in the debian/control file.  The string representation does not
+        include the type of the dependency.
+
+        Example for an unversioned dependency:
+          python3
+
+        Example for a versioned dependency:
+          python3 >= 3.2
+
+        .. versionadded:: 1.0.0
+        """
+        if self.version:
+            return '%s %s %s' % (self.name, self.relation_deb, self.version)
+        else:
+            return self.name
+
+    @property
+    def rawtype(self):
+        # type: () -> str
+        """Type of the dependency.
+
+        This should be one of 'Breaks', 'Conflicts', 'Depends', 'Enhances',
+        'PreDepends', 'Recommends', 'Replaces', 'Suggests'.
+
+        Additional types might be added in the future.
+        """
+        return self._dep.dep_type_untranslated
+
+    @property
+    def pre_depend(self):
+        # type: () -> bool
+        """Whether this is a PreDepends."""
+        return self._dep.dep_type_untranslated == 'PreDepends'
+
+
+class Dependency(List[BaseDependency]):
+    """Represent an Or-group of dependencies.
+
+    Attributes defined here:
+        or_dependencies - The possible choices
+        rawstr - String represenation of the Or-group of dependencies
+        rawtype - The type of the dependencies in the Or-group
+        target_version - A list of Versions which satisfy this Or-group of deps
+    """
+
+    def __init__(self, version, base_deps, rawtype):
+        # type: (Version, List[BaseDependency], str) -> None
+        super(Dependency, self).__init__(base_deps)
+        self._version = version  # apt.package.Version
+        self._rawtype = rawtype
+
+    def __str__(self):
+        # type: () -> str
+        return '%s: %s' % (self.rawtype, self.rawstr)
+
+    def __repr__(self):
+        # type: () -> str
+        return '<Dependency: [%s]>' % (', '.join(repr(bd) for bd in self))
+
+    @property
+    def or_dependencies(self):
+        # type: () -> Dependency
+        return self
+
+    @property
+    def rawstr(self):
+        # type: () -> str
+        """String represenation of the Or-group of dependencies.
+
+        Returns the string representation of the Or-group of dependencies as it
+        would be written in the debian/control file.  The string representation
+        does not include the type of the Or-group of dependencies.
+
+        Example:
+          python2 >= 2.7 | python3
+
+        .. versionadded:: 1.0.0
+        """
+        return ' | '.join(bd.rawstr for bd in self)
+
+    @property
+    def rawtype(self):
+        # type: () -> str
+        """Type of the Or-group of dependency.
+
+        This should be one of 'Breaks', 'Conflicts', 'Depends', 'Enhances',
+        'PreDepends', 'Recommends', 'Replaces', 'Suggests'.
+
+        Additional types might be added in the future.
+
+        .. versionadded:: 1.0.0
+        """
+        return self._rawtype
+
+    @property
+    def target_versions(self):
+        # type: () -> List[Version]
+        """A list of all Version objects which satisfy this Or-group of deps.
+
+        .. versionadded:: 1.0.0
+        """
+        tvers = []  # type: List[Version]
+        for bd in self:  # apt.package.Dependency
+            for tver in bd.target_versions:  # apt.package.Version
+                if tver not in tvers:
+                    tvers.append(tver)
+        return tvers
+
+    @property
+    def installed_target_versions(self):
+        # type: () -> List[Version]
+        """A list of all installed Version objects which satisfy this dep.
+
+        .. versionadded:: 1.0.0
+        """
+        return [tver for tver in self.target_versions if tver.is_installed]
+
+
+class Origin(object):
+    """The origin of a version.
+
+    Attributes defined here:
+        archive   - The archive (eg. unstable)
+        component - The component (eg. main)
+        label     - The Label, as set in the Release file
+        origin    - The Origin, as set in the Release file
+        codename  - The Codename, as set in the Release file
+        site      - The hostname of the site.
+        trusted   - Boolean value whether this is trustworthy.
+    """
+
+    def __init__(self, pkg, packagefile):
+        # type: (Package, apt_pkg.PackageFile) -> None
+        self.archive = packagefile.archive
+        self.component = packagefile.component
+        self.label = packagefile.label
+        self.origin = packagefile.origin
+        self.codename = packagefile.codename
+        self.site = packagefile.site
+        self.not_automatic = packagefile.not_automatic
+        # check the trust
+        indexfile = pkg._pcache._list.find_index(packagefile)
+        if indexfile and indexfile.is_trusted:
+            self.trusted = True
+        else:
+            self.trusted = False
+
+    def __repr__(self):
+        # type: () -> str
+        return ("<Origin component:%r archive:%r origin:%r label:%r "
+                "site:%r isTrusted:%r>") % (self.component, self.archive,
+                                            self.origin, self.label,
+                                            self.site, self.trusted)
+
+
+class Record(Mapping[Any, Any]):
+    """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.
+
+    """
+
+    def __init__(self, record_str):
+        # type: (str) -> None
+        self._rec = apt_pkg.TagSection(record_str)
+
+    def __hash__(self):
+        # type: () -> int
+        return hash(self._rec)
+
+    def __str__(self):
+        # type: () -> str
+        return str(self._rec)
+
+    def __getitem__(self, key):
+        # type: (str) -> str
+        return self._rec[key]
+
+    def __contains__(self, key):
+        # type: (object) -> bool
+        return key in self._rec
+
+    def __iter__(self):
+        # type: () -> Iterator[str]
+        return iter(self._rec.keys())
+
+    def iteritems(self):
+        # type: () -> Iterable[Tuple[object, str]]
+        """An iterator over the (key, value) items of the record."""
+        for key in self._rec.keys():
+            yield key, self._rec[key]
+
+    def get(self, key, default=None):
+        # type: (str, object) -> object
+        """Return record[key] if key in record, else *default*.
+
+        The parameter *default* must be either a string or None.
+        """
+        return self._rec.get(key, default)
+
+    def has_key(self, key):
+        # type: (str) -> bool
+        """deprecated form of ``key in x``."""
+        return key in self._rec
+
+    def __len__(self):
+        # type: () -> int
+        return len(self._rec)
+
+
+class Version(object):
+    """Representation of a package version.
+
+    The Version class contains all information related to a
+    specific package version.
+
+    .. versionadded:: 0.7.9
+    """
+
+    def __init__(self, package, cand):
+        # type: (Package, apt_pkg.Version) -> None
+        self.package = package
+        self._cand = cand
+        self.package._pcache._weakversions.add(self)
+
+    def _cmp(self, other):
+        # type: (Any) -> Union[int, Any]
+        """Compares against another apt.Version object or a version string.
+
+        This method behaves like Python 2's cmp builtin and returns an integer
+        according to the outcome.  The return value is negative in case of
+        self < other, zero if self == other and positive if self > other.
+
+        The comparison includes the package name and architecture if other is
+        an apt.Version object.  If other isn't an apt.Version object it'll be
+        assumed that other is a version string (without package name/arch).
+
+        .. versionchanged:: 1.0.0
+        """
+        # Assume that other is an apt.Version object.
+        try:
+            self_name = self.package.fullname
+            other_name = other.package.fullname
+            if self_name < other_name:
+                return -1
+            elif self_name > other_name:
+                return 1
+            return apt_pkg.version_compare(self._cand.ver_str, other.version)
+        except AttributeError:
+            # Assume that other is a string that only contains the version.
+            try:
+                return apt_pkg.version_compare(self._cand.ver_str, other)
+            except TypeError:
+                return NotImplemented
+
+    def __eq__(self, other):
+        # type: (object) -> bool
+        return self._cmp(other) == 0
+
+    def __ge__(self, other):
+        # type: (Version) -> bool
+        return self._cmp(other) >= 0
+
+    def __gt__(self, other):
+        # type: (Version) -> bool
+        return self._cmp(other) > 0
+
+    def __le__(self, other):
+        # type: (Version) -> bool
+        return self._cmp(other) <= 0
+
+    def __lt__(self, other):
+        # type: (Version) -> bool
+        return self._cmp(other) < 0
+
+    def __ne__(self, other):
+        # type: (object) -> Union[bool, Any]
+        try:
+            return self._cmp(other) != 0
+        except TypeError:
+            return NotImplemented
+
+    def __hash__(self):
+        # type: () -> int
+        return self._cand.hash
+
+    def __str__(self):
+        # type: () -> str
+        return '%s=%s' % (self.package.name, self.version)
+
+    def __repr__(self):
+        # type: () -> str
+        return '<Version: package:%r version:%r>' % (self.package.name,
+                                                     self.version)
+
+    @property
+    def _records(self):
+        # type: () -> apt_pkg.PackageRecords
+        """Internal helper that moves the Records to the right position."""
+        # If changing lookup, change fetch_binary() as well
+        if not self.package._pcache._records.lookup(self._cand.file_list[0]):
+            raise LookupError("Could not lookup record")
+
+        return self.package._pcache._records
+
+    @property
+    def _translated_records(self):
+        # type: () -> Optional[apt_pkg.PackageRecords]
+        """Internal helper to get the translated description."""
+        desc_iter = self._cand.translated_description
+        if self.package._pcache._records.lookup(desc_iter.file_list.pop(0)):
+            return self.package._pcache._records
+        return None
+
+    @property
+    def installed_size(self):
+        # type: () -> int
+        """Return the size of the package when installed."""
+        return self._cand.installed_size
+
+    @property
+    def homepage(self):
+        # type: () -> str
+        """Return the homepage for the package."""
+        return self._records.homepage
+
+    @property
+    def size(self):
+        # type: () -> int
+        """Return the size of the package."""
+        return self._cand.size
+
+    @property
+    def architecture(self):
+        # type: () -> str
+        """Return the architecture of the package version."""
+        return self._cand.arch
+
+    @property
+    def downloadable(self):
+        # type: () -> bool
+        """Return whether the version of the package is downloadable."""
+        return bool(self._cand.downloadable)
+
+    @property
+    def is_installed(self):
+        # type: () -> bool
+        """Return wether this version of the package is currently installed.
+
+        .. versionadded:: 1.0.0
+        """
+        inst_ver = self.package.installed
+        return (inst_ver is not None and inst_ver._cand.id == self._cand.id)
+
+    @property
+    def version(self):
+        # type: () -> str
+        """Return the version as a string."""
+        return self._cand.ver_str
+
+    @property
+    def summary(self):
+        # type: () -> Optional[str]
+        """Return the short description (one line summary)."""
+        records = self._translated_records
+        return records.short_desc if records is not None else None
+
+    @property
+    def raw_description(self):
+        # type: () -> str
+        """return the long description (raw)."""
+        return self._records.long_desc
+
+    @property
+    def section(self):
+        # type: () -> str
+        """Return the section of the package."""
+        return self._cand.section
+
+    @property
+    def description(self):
+        # type: () -> str
+        """Return the formatted long description.
+
+        Return the formatted long description according to the Debian policy
+        (Chapter 5.6.13).
+        See http://www.debian.org/doc/debian-policy/ch-controlfields.html
+        for more information.
+        """
+        desc = ''
+        records = self._translated_records
+        dsc = records.long_desc if records is not None else None
+
+        if not dsc:
+            return _("Missing description for '%s'."
+                     "Please report.") % (self.package.name)
+
+        try:
+            if not isinstance(dsc, str):
+                # Only convert where needed (i.e. Python 2.X)
+                dsc = dsc.decode("utf-8")
+        except UnicodeDecodeError as err:
+            return _("Invalid unicode in description for '%s' (%s). "
+                     "Please report.") % (self.package.name, err)
+
+        lines = iter(dsc.split("\n"))
+        # Skip the first line, since its a duplication of the summary
+        next(lines)
+        for raw_line in lines:
+            if raw_line.strip() == ".":
+                # The line is just line break
+                if not desc.endswith("\n"):
+                    desc += "\n\n"
+                continue
+            if raw_line.startswith("  "):
+                # The line should be displayed verbatim without word wrapping
+                if not desc.endswith("\n"):
+                    line = "\n%s\n" % raw_line[2:]
+                else:
+                    line = "%s\n" % raw_line[2:]
+            elif raw_line.startswith(" "):
+                # The line is part of a paragraph.
+                if desc.endswith("\n") or desc == "":
+                    # Skip the leading white space
+                    line = raw_line[1:]
+                else:
+                    line = raw_line
+            else:
+                line = raw_line
+            # Add current line to the description
+            desc += line
+        return desc
+
+    @property
+    def source_name(self):
+        # type: () -> str
+        """Return the name of the source package."""
+        try:
+            return self._records.source_pkg or self.package.shortname
+        except IndexError:
+            return self.package.shortname
+
+    @property
+    def source_version(self):
+        # type: () -> str
+        """Return the version of the source package."""
+        try:
+            return self._records.source_ver or self._cand.ver_str
+        except IndexError:
+            return self._cand.ver_str
+
+    @property
+    def priority(self):
+        # type: () -> str
+        """Return the priority of the package, as string."""
+        return self._cand.priority_str
+
+    @property
+    def policy_priority(self):
+        # type: () -> int
+        """Return the internal policy priority as a number.
+           See apt_preferences(5) for more information about what it means.
+        """
+        return self.package._pcache._depcache.policy.get_priority(self._cand)
+
+    @property
+    def record(self):
+        # type: () -> Record
+        """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):
+        # type: (str) -> List[Dependency]
+        """Return a list of Dependency objects for the given types.
+
+        Multiple types can be specified. Possible types are:
+        'Breaks', 'Conflicts', 'Depends', 'Enhances', 'PreDepends',
+        'Recommends', 'Replaces', 'Suggests'
+
+        Additional types might be added in the future.
+        """
+        depends_list = []
+        depends = self._cand.depends_list
+        for type_ in types:
+            try:
+                for dep_ver_list in depends[type_]:
+                    base_deps = []
+                    for dep_or in dep_ver_list:
+                        base_deps.append(BaseDependency(self, dep_or))
+                    depends_list.append(Dependency(self, base_deps, type_))
+            except KeyError:
+                pass
+        return depends_list
+
+    @property
+    def provides(self):
+        # type: () -> List[str]
+        """ Return a list of names that this version provides."""
+        return [p[0] for p in self._cand.provides_list]
+
+    @property
+    def enhances(self):
+        # type: () -> List[Dependency]
+        """Return the list of enhances for the package version."""
+        return self.get_dependencies("Enhances")
+
+    @property
+    def dependencies(self):
+        # type: () -> List[Dependency]
+        """Return the dependencies of the package version."""
+        return self.get_dependencies("PreDepends", "Depends")
+
+    @property
+    def recommends(self):
+        # type: () -> List[Dependency]
+        """Return the recommends of the package version."""
+        return self.get_dependencies("Recommends")
+
+    @property
+    def suggests(self):
+        # type: () -> List[Dependency]
+        """Return the suggests of the package version."""
+        return self.get_dependencies("Suggests")
+
+    @property
+    def origins(self):
+        # type: () -> List[Origin]
+        """Return a list of origins for the package version."""
+        origins = []
+        for (packagefile, _unused) in self._cand.file_list:
+            origins.append(Origin(self.package, packagefile))
+        return origins
+
+    @property
+    def filename(self):
+        # type: () -> str
+        """Return the path to the file inside the archive.
+
+        .. versionadded:: 0.7.10
+        """
+        return self._records.filename
+
+    @property
+    def md5(self):
+        # type: () -> str
+        """Return the md5sum of the binary.
+
+        .. versionadded:: 0.7.10
+        """
+        return self._records.md5_hash
+
+    @property
+    def sha1(self):
+        # type: () -> str
+        """Return the sha1sum of the binary.
+
+        .. versionadded:: 0.7.10
+        """
+        return self._records.sha1_hash
+
+    @property
+    def sha256(self):
+        # type: () -> str
+        """Return the sha256sum of the binary.
+
+        .. versionadded:: 0.7.10
+        """
+        return self._records.sha256_hash
+
+    @property
+    def tasks(self):
+        # type: () -> Set[str]
+        """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):
+        # type: () -> Iterator[str]
+        """Return an iterator over all available urls.
+
+        .. versionadded:: 0.7.10
+        """
+        for (packagefile, _unused) in self._cand.file_list:
+            indexfile = self.package._pcache._list.find_index(packagefile)
+            if indexfile:
+                yield indexfile.archive_uri(self._records.filename)
+
+    @property
+    def uris(self):
+        # type: () -> List[str]
+        """Return a list of all available uris for the binary.
+
+        .. versionadded:: 0.7.10
+        """
+        return list(self._uris())
+
+    @property
+    def uri(self):
+        # type: () -> Optional[str]
+        """Return a single URI for the binary.
+
+        .. versionadded:: 0.7.10
+        """
+        try:
+            return next(iter(self._uris()))
+        except StopIteration:
+            return None
+
+    def fetch_binary(self, destdir='', progress=None,
+                     allow_unauthenticated=None):
+        # type: (str, Optional[AcquireProgress], Optional[bool]) -> str
+        """Fetch the binary version of the package.
+
+        The parameter *destdir* specifies the directory where the package will
+        be fetched to.
+
+        The parameter *progress* may refer to an apt_pkg.AcquireProgress()
+        object. If not specified or None, apt.progress.text.AcquireProgress()
+        is used.
+
+        The keyword-only parameter *allow_unauthenticated* specifies whether
+        to allow unauthenticated downloads. If not specified, it defaults to
+        the configuration option `APT::Get::AllowUnauthenticated`.
+
+        .. versionadded:: 0.7.10
+        """
+        if allow_unauthenticated is None:
+            allow_unauthenticated = apt_pkg.config.find_b("APT::Get::"
+                                        "AllowUnauthenticated", False)
+        base = os.path.basename(self._records.filename)
+        destfile = os.path.join(destdir, base)
+        if _file_is_same(destfile, self.size, self._records.hashes):
+            logging.debug('Ignoring already existing file: %s' % destfile)
+            return os.path.abspath(destfile)
+
+        # Verify that the index is actually trusted
+        pfile, offset = self._cand.file_list[0]
+        index = self.package._pcache._list.find_index(pfile)
+
+        if not (allow_unauthenticated or (index and index.is_trusted)):
+            raise UntrustedError("Could not fetch %s %s source package: "
+                                 "Source %r is not trusted" %
+                                 (self.package.name, self.version,
+                                  getattr(index, "describe", "<unkown>")))
+        if not self.uri:
+            raise ValueError("No URI for this binary.")
+        hashes = self._records.hashes
+        if not (allow_unauthenticated or hashes.usable):
+            raise UntrustedError("The item %r could not be fetched: "
+                                     "No trusted hash found." %
+                                     destfile)
+        acq = apt_pkg.Acquire(progress or apt.progress.text.AcquireProgress())
+        acqfile = apt_pkg.AcquireFile(acq, self.uri, hashes,
+                                      self.size, base, destfile=destfile)
+        acq.run()
+
+        if acqfile.status != acqfile.STAT_DONE:
+            raise FetchError("The item %r could not be fetched: %s" %
+                             (acqfile.destfile, acqfile.error_text))
+
+        return os.path.abspath(destfile)
+
+    def fetch_source(self, destdir="", progress=None, unpack=True,
+                     allow_unauthenticated=None):
+        # type: (str, Optional[AcquireProgress], bool, Optional[bool]) -> str
+        """Get the source code of a package.
+
+        The parameter *destdir* specifies the directory where the source will
+        be fetched to.
+
+        The parameter *progress* may refer to an apt_pkg.AcquireProgress()
+        object. If not specified or None, apt.progress.text.AcquireProgress()
+        is used.
+
+        The parameter *unpack* describes whether the source should be unpacked
+        (``True``) or not (``False``). By default, it is unpacked.
+
+        If *unpack* is ``True``, the path to the extracted directory is
+        returned. Otherwise, the path to the .dsc file is returned.
+
+        The keyword-only parameter *allow_unauthenticated* specifies whether
+        to allow unauthenticated downloads. If not specified, it defaults to
+        the configuration option `APT::Get::AllowUnauthenticated`.
+        """
+        if allow_unauthenticated is None:
+            allow_unauthenticated = apt_pkg.config.find_b("APT::Get::"
+                                        "AllowUnauthenticated", False)
+
+        src = apt_pkg.SourceRecords()
+        acq = apt_pkg.Acquire(progress or apt.progress.text.AcquireProgress())
+
+        dsc = None
+        record = self._records
+        source_name = record.source_pkg or self.package.shortname
+        source_version = record.source_ver or self._cand.ver_str
+        source_lookup = src.lookup(source_name)
+
+        while source_lookup and source_version != src.version:
+            source_lookup = src.lookup(source_name)
+        if not source_lookup:
+            raise ValueError("No source for %r" % self)
+        files = list()
+
+        if not (allow_unauthenticated or src.index.is_trusted):
+            raise UntrustedError("Could not fetch %s %s source package: "
+                                 "Source %r is not trusted" %
+                                 (self.package.name, self.version,
+                                  src.index.describe))
+        for fil in src.files:
+            base = os.path.basename(fil.path)
+            destfile = os.path.join(destdir, base)
+            if fil.type == 'dsc':
+                dsc = destfile
+            if _file_is_same(destfile, fil.size, fil.hashes):
+                logging.debug('Ignoring already existing file: %s' % destfile)
+                continue
+
+            if not (allow_unauthenticated or fil.hashes.usable):
+                raise UntrustedError("The item %r could not be fetched: "
+                                         "No trusted hash found." %
+                                         destfile)
+            files.append(apt_pkg.AcquireFile(acq,
+                            src.index.archive_uri(fil.path),
+                            fil.hashes, fil.size, base, destfile=destfile))
+        acq.run()
+
+        if dsc is None:
+            raise ValueError("No source for %r" % self)
+
+        for item in acq.items:
+            if item.status != item.STAT_DONE:
+                raise FetchError("The item %r could not be fetched: %s" %
+                                 (item.destfile, item.error_text))
+
+        if unpack:
+            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)
+        else:
+            return os.path.abspath(dsc)
+
+
+class VersionList(Sequence[Version]):
+    """Provide a mapping & sequence interface to all versions of a package.
+
+    This class can be used like a dictionary, where version strings are the
+    keys. It can also be used as a sequence, where integers are the keys.
+
+    You can also convert this to a dictionary or a list, using the usual way
+    of dict(version_list) or list(version_list). This is useful if you need
+    to access the version objects multiple times, because they do not have to
+    be recreated this way.
+
+    Examples ('package.versions' being a version list):
+        '0.7.92' in package.versions # Check whether 0.7.92 is a valid version.
+        package.versions[0] # Return first version or raise IndexError
+        package.versions[0:2] # Return a new VersionList for objects 0-2
+        package.versions['0.7.92'] # Return version 0.7.92 or raise KeyError
+        package.versions.keys() # All keys, as strings.
+        max(package.versions)
+    """
+
+    def __init__(self, package, slice_=None):
+        # type: (Package, Optional[slice]) -> None
+        self._package = package  # apt.package.Package()
+        self._versions = package._pkg.version_list  # [apt_pkg.Version(), ...]
+        if slice_:
+            self._versions = self._versions[slice_]
+
+    def __getitem__(self, item):
+        # type: (Union[int, slice, str]) -> Any
+        # FIXME: Should not be returning Any, should have overloads; but
+        # pyflakes complains
+        if isinstance(item, slice):
+            return self.__class__(self._package, item)
+        try:
+            # Sequence interface, item is an integer
+            return Version(self._package, self._versions[item])  # type: ignore
+        except TypeError:
+            # Dictionary interface item is a string.
+            for ver in self._versions:
+                if ver.ver_str == item:
+                    return Version(self._package, ver)
+        raise KeyError("Version: %r not found." % (item))
+
+    def __str__(self):
+        # type: () -> str
+        return '[%s]' % (', '.join(str(ver) for ver in self))
+
+    def __repr__(self):
+        # type: () -> str
+        return '<VersionList: %r>' % self.keys()
+
+    def __iter__(self):
+        # type: () -> Iterator[Version]
+        """Return an iterator over all value objects."""
+        return (Version(self._package, ver) for ver in self._versions)
+
+    def __contains__(self, item):
+        # type: (object) -> bool
+        if isinstance(item, Version):  # Sequence interface
+            item = item.version
+        # Dictionary interface.
+        for ver in self._versions:
+            if ver.ver_str == item:
+                return True
+        return False
+
+    def __eq__(self, other):
+        # type: (Any) -> bool
+        return list(self) == list(other)
+
+    def __len__(self):
+        # type: () -> int
+        return len(self._versions)
+
+    # Mapping interface
+
+    def keys(self):
+        # type: () -> List[str]
+        """Return a list of all versions, as strings."""
+        return [ver.ver_str for ver in self._versions]
+
+    def get(self, key, default=None):
+        # type: (str, Optional[Version]) -> Optional[Version]
+        """Return the key or the default."""
+        try:
+            return self[key]  # type: ignore  # FIXME: should be deterined automatically # noqa
+        except LookupError:
+            return default
+
+
+class Package(object):
+    """Representation of a package in a cache.
+
+    This class provides methods and properties for working with a package. It
+    lets you mark the package for installation, check if it is installed, and
+    much more.
+    """
+
+    def __init__(self, pcache, pkgiter):
+        # type: (apt.Cache, apt_pkg.Package) -> None
+        """ Init the Package object """
+        self._pkg = pkgiter
+        self._pcache = pcache           # python cache in cache.py
+        self._changelog = ""            # Cached changelog
+
+    def __str__(self):
+        # type: () -> str
+        return self.name
+
+    def __repr__(self):
+        # type: () -> str
+        return '<Package: name:%r architecture=%r id:%r>' % (
+            self._pkg.name, self._pkg.architecture, self._pkg.id)
+
+    def __lt__(self, other):
+        # type: (Package) -> bool
+        return self.name < other.name
+
+    @property
+    def candidate(self):
+        # type: () -> Optional[Version]
+        """Return the candidate version of the package.
+
+        This property is writeable to allow you to set the candidate version
+        of the package. Just assign a Version() object, and it will be set as
+        the candidate version.
+        """
+        cand = self._pcache._depcache.get_candidate_ver(self._pkg)
+        if cand is not None:
+            return Version(self, cand)
+        return None
+
+    @candidate.setter
+    def candidate(self, version):
+        # type: (Version) -> None
+        """Set the candidate version of the package."""
+        self._pcache.cache_pre_change()
+        self._pcache._depcache.set_candidate_ver(self._pkg, version._cand)
+        self._pcache.cache_post_change()
+
+    @property
+    def installed(self):
+        # type: () -> Optional[Version]
+        """Return the currently installed version of the package.
+
+        .. versionadded:: 0.7.9
+        """
+        if self._pkg.current_ver is not None:
+            return Version(self, self._pkg.current_ver)
+        return None
+
+    @property
+    def name(self):
+        # type: () -> str
+        """Return the name of the package, possibly including architecture.
+
+        If the package is not part of the system's preferred architecture,
+        return the same as :attr:`fullname`, otherwise return the same
+        as :attr:`shortname`
+
+        .. versionchanged:: 0.7.100.3
+
+        As part of multi-arch, this field now may include architecture
+        information.
+        """
+        return self._pkg.get_fullname(True)
+
+    @property
+    def fullname(self):
+        # type: () -> str
+        """Return the name of the package, including architecture.
+
+        Note that as for :meth:`architecture`, this returns the
+        native architecture for Architecture: all packages.
+
+        .. versionadded:: 0.7.100.3"""
+        return self._pkg.get_fullname(False)
+
+    @property
+    def shortname(self):
+        # type: () -> str
+        """Return the name of the package, without architecture.
+
+        .. versionadded:: 0.7.100.3"""
+        return self._pkg.name
+
+    @property
+    def id(self):
+        # type: () -> int
+        """Return a uniq ID for the package.
+
+        This can be used eg. to store additional information about the pkg."""
+        return self._pkg.id
+
+    @property
+    def essential(self):
+        # type: () -> bool
+        """Return True if the package is an essential part of the system."""
+        return self._pkg.essential
+
+    def architecture(self):
+        # type: () -> str
+        """Return the Architecture of the package.
+
+        Note that for Architecture: all packages, this returns the
+        native architecture, as they are internally treated like native
+        packages. To get the concrete architecture, look at the
+        :attr:`Version.architecture` attribute.
+
+        .. versionchanged:: 0.7.100.3
+            This is now the package's architecture in the multi-arch sense,
+            previously it was the architecture of the candidate version
+            and deprecated.
+        """
+        return self._pkg.architecture
+
+    # depcache states
+
+    @property
+    def marked_install(self):
+        # type: () -> bool
+        """Return ``True`` if the package is marked for install."""
+        return self._pcache._depcache.marked_install(self._pkg)
+
+    @property
+    def marked_upgrade(self):
+        # type: () -> bool
+        """Return ``True`` if the package is marked for upgrade."""
+        return self._pcache._depcache.marked_upgrade(self._pkg)
+
+    @property
+    def marked_delete(self):
+        # type: () -> bool
+        """Return ``True`` if the package is marked for delete."""
+        return self._pcache._depcache.marked_delete(self._pkg)
+
+    @property
+    def marked_keep(self):
+        # type: () -> bool
+        """Return ``True`` if the package is marked for keep."""
+        return self._pcache._depcache.marked_keep(self._pkg)
+
+    @property
+    def marked_downgrade(self):
+        # type: () -> bool
+        """ Package is marked for downgrade """
+        return self._pcache._depcache.marked_downgrade(self._pkg)
+
+    @property
+    def marked_reinstall(self):
+        # type: () -> bool
+        """Return ``True`` if the package is marked for reinstall."""
+        return self._pcache._depcache.marked_reinstall(self._pkg)
+
+    @property
+    def is_installed(self):
+        # type: () -> bool
+        """Return ``True`` if the package is installed."""
+        return (self._pkg.current_ver is not None)
+
+    @property
+    def is_upgradable(self):
+        # type: () -> bool
+        """Return ``True`` if the package is upgradable."""
+        return (self.is_installed and
+                self._pcache._depcache.is_upgradable(self._pkg))
+
+    @property
+    def is_auto_removable(self):
+        # type: () -> bool
+        """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.is_installed or self.marked_install) and
+                self._pcache._depcache.is_garbage(self._pkg))
+
+    @property
+    def is_auto_installed(self):
+        # type: () -> bool
+        """Return whether the package is marked as automatically installed."""
+        return self._pcache._depcache.is_auto_installed(self._pkg)
+    # sizes
+
+    @property
+    def installed_files(self):
+        # type: () -> List[str]
+        """Return a list of files installed by the package.
+
+        Return a list of unicode names of the files which have
+        been installed by this package
+        """
+        for name in self.name, self.fullname:
+            path = "/var/lib/dpkg/info/%s.list" % name
+            try:
+                with open(path, "rb") as file_list:
+                    return file_list.read().decode("utf-8").split(u"\n")
+            except EnvironmentError:
+                continue
+
+        return []
+
+    def get_changelog(self, uri=None, cancel_lock=None):
+        # type: (Optional[str], Optional[threading.Event]) -> str
+        """
+        Download the changelog of the package and return it as unicode
+        string.
+
+        The parameter *uri* refers to the uri of the changelog file. It may
+        contain multiple named variables which will be substitued. These
+        variables are (src_section, prefix, src_pkg, src_ver). An example is
+        the Ubuntu changelog::
+
+            "http://changelogs.ubuntu.com/changelogs/pool" \\
+                "/%(src_section)s/%(prefix)s/%(src_pkg)s" \\
+                "/%(src_pkg)s_%(src_ver)s/changelog"
+
+        The parameter *cancel_lock* refers to an instance of threading.Event,
+        which if set, prevents the download.
+        """
+        # Return a cached changelog if available
+        if self._changelog != u"":
+            return self._changelog
+
+        if not self.candidate:
+            return _("The list of changes is not available")
+
+        if uri is None:
+            if self.candidate.origins[0].origin == "Debian":
+                uri = "http://packages.debian.org/changelogs/pool" \
+                      "/%(src_section)s/%(prefix)s/%(src_pkg)s" \
+                      "/%(src_pkg)s_%(src_ver)s/changelog"
+            elif self.candidate.origins[0].origin == "Ubuntu":
+                uri = "http://changelogs.ubuntu.com/changelogs/pool" \
+                      "/%(src_section)s/%(prefix)s/%(src_pkg)s" \
+                      "/%(src_pkg)s_%(src_ver)s/changelog"
+            else:
+                res = _("The list of changes is not available")
+                if isinstance(res, str):
+                    return res
+                else:
+                    return res.decode("utf-8")
+
+        # get the src package name
+        src_pkg = self.candidate.source_name
+
+        # assume "main" section
+        src_section = "main"
+        # use the section of the candidate as a starting point
+        section = self.candidate.section
+
+        # get the source version
+        src_ver = self.candidate.source_version
+
+        try:
+            # try to get the source version of the pkg, this differs
+            # for some (e.g. libnspr4 on ubuntu)
+            # this feature only works if the correct deb-src are in the
+            # sources.list otherwise we fall back to the binary version number
+            src_records = apt_pkg.SourceRecords()
+        except SystemError:
+            pass
+        else:
+            while src_records.lookup(src_pkg):
+                if not src_records.version:
+                    continue
+                if self.candidate.source_version == src_records.version:
+                    # Direct match, use it and do not do more lookups.
+                    src_ver = src_records.version
+                    section = src_records.section
+                    break
+                if apt_pkg.version_compare(src_records.version, src_ver) > 0:
+                    # The version is higher, it seems to match.
+                    src_ver = src_records.version
+                    section = src_records.section
+
+        section_split = section.split("/", 1)
+        if len(section_split) > 1:
+            src_section = section_split[0]
+        del section_split
+
+        # lib is handled special
+        prefix = src_pkg[0]
+        if src_pkg.startswith("lib"):
+            prefix = "lib" + src_pkg[3]
+
+        # stip epoch
+        src_ver_split = src_ver.split(":", 1)
+        if len(src_ver_split) > 1:
+            src_ver = "".join(src_ver_split[1:])
+        del src_ver_split
+
+        uri = uri % {"src_section": src_section,
+                     "prefix": prefix,
+                     "src_pkg": src_pkg,
+                     "src_ver": src_ver}
+
+        timeout = socket.getdefaulttimeout()
+
+        # FIXME: when python2.4 vanishes from the archive,
+        #        merge this into a single try..finally block (pep 341)
+        try:
+            try:
+                # Set a timeout for the changelog download
+                socket.setdefaulttimeout(2)
+
+                # Check if the download was canceled
+                if cancel_lock and cancel_lock.is_set():
+                    return u""
+                # FIXME: python3.2: Should be closed manually
+                changelog_file = urlopen(uri)
+                # do only get the lines that are new
+                changelog = u""
+                regexp = "^%s \\((.*)\\)(.*)$" % (re.escape(src_pkg))
+                while True:
+                    # Check if the download was canceled
+                    if cancel_lock and cancel_lock.is_set():
+                        return u""
+                    # Read changelog line by line
+                    line_raw = changelog_file.readline()
+                    if not line_raw:
+                        break
+                    # The changelog is encoded in utf-8, but since there isn't
+                    # any http header, urllib2 seems to treat it as ascii
+                    line = line_raw.decode("utf-8")
+
+                    #print line.encode('utf-8')
+                    match = re.match(regexp, line)
+                    if match:
+                        # strip epoch from installed version
+                        # and from changelog too
+                        installed = getattr(self.installed, 'version', None)
+                        if installed and ":" in installed:
+                            installed = installed.split(":", 1)[1]
+                        changelog_ver = match.group(1)
+                        if changelog_ver and ":" in changelog_ver:
+                            changelog_ver = changelog_ver.split(":", 1)[1]
+
+                        if (installed and apt_pkg.version_compare(
+                                changelog_ver, installed) <= 0):
+                            break
+                    # EOF (shouldn't really happen)
+                    changelog += line
+
+                # Print an error if we failed to extract a changelog
+                if len(changelog) == 0:
+                    changelog = _("The list of changes is not available")
+                    if not isinstance(changelog, str):
+                        changelog = changelog.decode("utf-8")
+                self._changelog = changelog
+
+            except HTTPError:
+                if self.candidate.origins[0].origin == "Ubuntu":
+                    res = _("The list of changes is not available yet.\n\n"
+                            "Please use "
+                            "http://launchpad.net/ubuntu/+source/%s/"
+                            "%s/+changelog\n"
+                            "until the changes become available or try again "
+                            "later.") % (src_pkg, src_ver)
+                else:
+                    res = _("The list of changes is not available")
+                if isinstance(res, str):
+                    return res
+                else:
+                    return res.decode("utf-8")
+            except (IOError, BadStatusLine):
+                res = _("Failed to download the list of changes. \nPlease "
+                        "check your Internet connection.")
+                if isinstance(res, str):
+                    return res
+                else:
+                    return res.decode("utf-8")
+        finally:
+            socket.setdefaulttimeout(timeout)
+        return self._changelog
+
+    @property
+    def versions(self):
+        # type: () -> VersionList
+        """Return a VersionList() object for all available versions.
+
+        .. versionadded:: 0.7.9
+        """
+        return VersionList(self)
+
+    @property
+    def is_inst_broken(self):
+        # type: () -> bool
+        """Return True if the to-be-installed package is broken."""
+        return self._pcache._depcache.is_inst_broken(self._pkg)
+
+    @property
+    def is_now_broken(self):
+        # type: () -> bool
+        """Return True if the installed package is broken."""
+        return self._pcache._depcache.is_now_broken(self._pkg)
+
+    @property
+    def has_config_files(self):
+        # type: () -> bool
+        """Checks whether the package is is the config-files state."""
+        return self. _pkg.current_state == apt_pkg.CURSTATE_CONFIG_FILES
+
+    # depcache actions
+
+    def mark_keep(self):
+        # type: () -> None
+        """Mark a package for keep."""
+        self._pcache.cache_pre_change()
+        self._pcache._depcache.mark_keep(self._pkg)
+        self._pcache.cache_post_change()
+
+    def mark_delete(self, auto_fix=True, purge=False):
+        # type: (bool, bool) -> None
+        """Mark a package for deletion.
+
+        If *auto_fix* is ``True``, the resolver will be run, trying to fix
+        broken packages.  This is the default.
+
+        If *purge* is ``True``, remove the configuration files of the package
+        as well.  The default is to keep the configuration.
+        """
+        self._pcache.cache_pre_change()
+        self._pcache._depcache.mark_delete(self._pkg, purge)
+        # try to fix broken stuffsta
+        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.resolve()
+        self._pcache.cache_post_change()
+
+    def mark_install(self, auto_fix=True, auto_inst=True, from_user=True):
+        # type: (bool, bool, bool) -> None
+        """Mark a package for install.
+
+        If *autoFix* is ``True``, the resolver will be run, trying to fix
+        broken packages.  This is the default.
+
+        If *autoInst* is ``True``, the dependencies of the packages will be
+        installed automatically.  This is the default.
+
+        If *fromUser* is ``True``, this package will not be marked as
+        automatically installed. This is the default. Set it to False if you
+        want to be able to automatically remove the package at a later stage
+        when no other package depends on it.
+        """
+        self._pcache.cache_pre_change()
+        self._pcache._depcache.mark_install(self._pkg, auto_inst, from_user)
+        # try to fix broken stuff
+        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)
+        self._pcache.cache_post_change()
+
+    def mark_upgrade(self, from_user=True):
+        # type: (bool) -> None
+        """Mark a package for upgrade."""
+        if self.is_upgradable:
+            auto = self.is_auto_installed
+            self.mark_install(from_user=from_user)
+            self.mark_auto(auto)
+        else:
+            # FIXME: we may want to throw a exception here
+            sys.stderr.write(("MarkUpgrade() called on a non-upgradeable pkg: "
+                              "'%s'\n") % self._pkg.name)
+
+    def mark_auto(self, auto=True):
+        # type: (bool) -> None
+        """Mark a package as automatically installed.
+
+        Call this function to mark a package as automatically installed. If the
+        optional parameter *auto* is set to ``False``, the package will not be
+        marked as automatically installed anymore. The default is ``True``.
+        """
+        self._pcache._depcache.mark_auto(self._pkg, auto)
+
+    def commit(self, fprogress, iprogress):
+        # type: (AcquireProgress, InstallProgress) -> None
+        """Commit the changes.
+
+        The parameter *fprogress* refers to a apt_pkg.AcquireProgress() object,
+        like apt.progress.text.AcquireProgress().
+
+        The parameter *iprogress* refers to an InstallProgress() object, as
+        found in apt.progress.base.
+        """
+        self._pcache._depcache.commit(fprogress, iprogress)
+
+
+@no_type_check
+def _test():
+    """Self-test."""
+    print("Self-test for the Package modul")
+    import random
+    apt_pkg.init()
+    progress = apt.progress.text.OpProgress()
+    cache = apt.Cache(progress)
+    pkg = cache["apt-utils"]
+    print("Name: %s " % pkg.name)
+    print("ID: %s " % pkg.id)
+    print("Priority (Candidate): %s " % pkg.candidate.priority)
+    print("Priority (Installed): %s " % pkg.installed.priority)
+    print("Installed: %s " % pkg.installed.version)
+    print("Candidate: %s " % pkg.candidate.version)
+    print("CandidateDownloadable: %s" % pkg.candidate.downloadable)
+    print("CandidateOrigins: %s" % pkg.candidate.origins)
+    print("SourcePkg: %s " % pkg.candidate.source_name)
+    print("Section: %s " % pkg.section)
+    print("Summary: %s" % pkg.candidate.summary)
+    print("Description (formatted) :\n%s" % pkg.candidate.description)
+    print("Description (unformatted):\n%s" % pkg.candidate.raw_description)
+    print("InstalledSize: %s " % pkg.candidate.installed_size)
+    print("PackageSize: %s " % pkg.candidate.size)
+    print("Dependencies: %s" % pkg.installed.dependencies)
+    print("Recommends: %s" % pkg.installed.recommends)
+    for dep in pkg.candidate.dependencies:
+        print(",".join("%s (%s) (%s) (%s)" % (o.name, o.version, o.relation,
+                       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"].get_changelog())
+    for i in True, False:
+        print("Running install on random upgradable pkgs with AutoFix: ", i)
+        for pkg in cache:
+            if pkg.is_upgradable:
+                if random.randint(0, 1) == 1:
+                    pkg.mark_install(i)
+        print("Broken: %s " % cache._depcache.broken_count)
+        print("InstCount: %s " % cache._depcache.inst_count)
+
+    print()
+    # get a new cache
+    for i in True, False:
+        print("Randomly remove some packages with AutoFix: %s" % i)
+        cache = apt.Cache(progress)
+        for name in cache.keys():
+            if random.randint(0, 1) == 1:
+                try:
+                    cache[name].mark_delete(i)
+                except SystemError:
+                    print("Error trying to remove: %s " % name)
+        print("Broken: %s " % cache._depcache.broken_count)
+        print("DelCount: %s " % cache._depcache.del_count)
+
+
+# self-test
+if __name__ == "__main__":
+    _test()

build/lib.linux-x86_64-cpython-310/apt/progress/__init__.py

@@ -0,0 +1,31 @@
+# apt/progress/__init__.py - Initialization file for apt.progress.
+#
+# Copyright (c) 2009 Julian Andres Klode <[email protected]>
+#
+# 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
+"""Progress reporting.
+
+This package provides progress reporting for the python-apt package. The module
+'base' provides classes with no output, and the module 'text' provides classes
+for terminals, etc.
+"""
+
+from __future__ import print_function
+
+from typing import Sequence
+
+
+__all__ = []  # type: Sequence[str]

build/lib.linux-x86_64-cpython-310/apt/progress/base.py

@@ -0,0 +1,354 @@
+# apt/progress/base.py - Base classes for progress reporting.
+#
+# Copyright (C) 2009 Julian Andres Klode <[email protected]>
+#
+# 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
+# pylint: disable-msg = R0201
+"""Base classes for progress reporting.
+
+Custom progress classes should inherit from these classes. They can also be
+used as dummy progress classes which simply do nothing.
+"""
+from __future__ import print_function
+
+import errno
+import fcntl
+import io
+import os
+import re
+import select
+import sys
+
+from typing import Optional, Union
+
+import apt_pkg
+
+__all__ = ['AcquireProgress', 'CdromProgress', 'InstallProgress', 'OpProgress']
+
+
+class AcquireProgress(object):
+    """Monitor object for downloads controlled by the Acquire class.
+
+    This is an mostly abstract class. You should subclass it and implement the
+    methods to get something useful.
+    """
+
+    current_bytes = current_cps = fetched_bytes = last_bytes = total_bytes \
+                  = 0.0
+    current_items = elapsed_time = total_items = 0
+
+    def done(self, item):
+        # type: (apt_pkg.AcquireItemDesc) -> None
+        """Invoked when an item is successfully and completely fetched."""
+
+    def fail(self, item):
+        # type: (apt_pkg.AcquireItemDesc) -> None
+        """Invoked when an item could not be fetched."""
+
+    def fetch(self, item):
+        # type: (apt_pkg.AcquireItemDesc) -> None
+        """Invoked when some of the item's data is fetched."""
+
+    def ims_hit(self, item):
+        # type: (apt_pkg.AcquireItemDesc) -> None
+        """Invoked when an item is confirmed to be up-to-date.
+
+        Invoked when an item is confirmed to be up-to-date. For instance,
+        when an HTTP download is informed that the file on the server was
+        not modified.
+        """
+
+    def media_change(self, media, drive):
+        # type: (str, str) -> bool
+        """Prompt the user to change the inserted removable media.
+
+        The parameter 'media' decribes the name of the media type that
+        should be changed, whereas the parameter 'drive' should be the
+        identifying name of the drive whose media should be changed.
+
+        This method should not return until the user has confirmed to the user
+        interface that the media change is complete. It must return True if
+        the user confirms the media change, or False to cancel it.
+        """
+        return False
+
+    def pulse(self, owner):
+        # type: (apt_pkg.Acquire) -> bool
+        """Periodically invoked while the Acquire process is underway.
+
+        This method gets invoked while the Acquire progress given by the
+        parameter 'owner' is underway. It should display information about
+        the current state.
+
+        This function returns a boolean value indicating whether the
+        acquisition should be continued (True) or cancelled (False).
+        """
+        return True
+
+    def start(self):
+        # type: () -> None
+        """Invoked when the Acquire process starts running."""
+        # Reset all our values.
+        self.current_bytes = 0.0
+        self.current_cps = 0.0
+        self.current_items = 0
+        self.elapsed_time = 0
+        self.fetched_bytes = 0.0
+        self.last_bytes = 0.0
+        self.total_bytes = 0.0
+        self.total_items = 0
+
+    def stop(self):
+        # type: () -> None
+        """Invoked when the Acquire process stops running."""
+
+
+class CdromProgress(object):
+    """Base class for reporting the progress of adding a cdrom.
+
+    Can be used with apt_pkg.Cdrom to produce an utility like apt-cdrom. The
+    attribute 'total_steps' defines the total number of steps and can be used
+    in update() to display the current progress.
+    """
+
+    total_steps = 0
+
+    def ask_cdrom_name(self):
+        # type: () -> Optional[str]
+        """Ask for the name of the cdrom.
+
+        If a name has been provided, return it. Otherwise, return None to
+        cancel the operation.
+        """
+
+    def change_cdrom(self):
+        # type: () -> bool
+        """Ask for the CD-ROM to be changed.
+
+        Return True once the cdrom has been changed or False to cancel the
+        operation.
+        """
+
+    def update(self, text, current):
+        # type: (str, int) -> None
+        """Periodically invoked to update the interface.
+
+        The string 'text' defines the text which should be displayed. The
+        integer 'current' defines the number of completed steps.
+        """
+
+
+class InstallProgress(object):
+    """Class to report the progress of installing packages."""
+
+    child_pid, percent, select_timeout, status = 0, 0.0, 0.1, ""
+
+    def __init__(self):
+        # type: () -> None
+        (self.statusfd, self.writefd) = os.pipe()
+        # These will leak fds, but fixing this safely requires API changes.
+        self.write_stream = os.fdopen(self.writefd, "w")  # type: io.TextIOBase
+        self.status_stream = os.fdopen(self.statusfd, "r")  # type: io.TextIOBase # noqa
+        fcntl.fcntl(self.statusfd, fcntl.F_SETFL, os.O_NONBLOCK)
+
+    def start_update(self):
+        # type: () -> None
+        """(Abstract) Start update."""
+
+    def finish_update(self):
+        # type: () -> None
+        """(Abstract) Called when update has finished."""
+
+    def __enter__(self):
+        # type: () -> InstallProgress
+        return self
+
+    def __exit__(self, type, value, traceback):
+        # type: (object, object, object) -> None
+        self.write_stream.close()
+        self.status_stream.close()
+
+    def error(self, pkg, errormsg):
+        # type: (str, str) -> None
+        """(Abstract) Called when a error is detected during the install."""
+
+    def conffile(self, current, new):
+        # type: (str, str) -> None
+        """(Abstract) Called when a conffile question from dpkg is detected."""
+
+    def status_change(self, pkg, percent, status):
+        # type: (str, float, str) -> None
+        """(Abstract) Called when the APT status changed."""
+
+    def dpkg_status_change(self, pkg, status):
+        # type: (str, str) -> None
+        """(Abstract) Called when the dpkg status changed."""
+
+    def processing(self, pkg, stage):
+        # type: (str, str) -> None
+        """(Abstract) Sent just before a processing stage starts.
+
+        The parameter 'stage' is one of "upgrade", "install"
+        (both sent before unpacking), "configure", "trigproc", "remove",
+        "purge". This method is used for dpkg only.
+        """
+
+    def run(self, obj):
+        # type: (Union[apt_pkg.PackageManager, Union[bytes, str]]) -> int
+        """Install using the object 'obj'.
+
+        This functions runs install actions. The parameter 'obj' may either
+        be a PackageManager object in which case its do_install() method is
+        called or the path to a deb file.
+
+        If the object is a PackageManager, the functions returns the result
+        of calling its do_install() method. Otherwise, the function returns
+        the exit status of dpkg. In both cases, 0 means that there were no
+        problems.
+        """
+        pid = self.fork()
+        if pid == 0:
+            try:
+                # PEP-446 implemented in Python 3.4 made all descriptors
+                # CLOEXEC, but we need to be able to pass writefd to dpkg
+                # when we spawn it
+                os.set_inheritable(self.writefd, True)
+            except AttributeError:  # if we don't have os.set_inheritable()
+                pass
+            # pm.do_install might raise a exception,
+            # when this happens, we need to catch
+            # it, otherwise os._exit() is not run
+            # and the execution continues in the
+            # parent code leading to very confusing bugs
+            try:
+                os._exit(obj.do_install(self.write_stream.fileno()))  # type: ignore # noqa
+            except AttributeError:
+                os._exit(os.spawnlp(os.P_WAIT, "dpkg", "dpkg", "--status-fd",
+                                    str(self.write_stream.fileno()), "-i",
+                                    obj))  # type: ignore # noqa
+            except Exception as e:
+                sys.stderr.write("%s\n" % e)
+                os._exit(apt_pkg.PackageManager.RESULT_FAILED)
+
+        self.child_pid = pid
+        res = self.wait_child()
+        return os.WEXITSTATUS(res)
+
+    def fork(self):
+        # type: () -> int
+        """Fork."""
+        return os.fork()
+
+    def update_interface(self):
+        # type: () -> None
+        """Update the interface."""
+        try:
+            line = self.status_stream.readline()
+        except IOError as err:
+            # resource temporarly unavailable is ignored
+            if err.errno != errno.EAGAIN and err.errno != errno.EWOULDBLOCK:
+                print(err.strerror)
+            return
+
+        pkgname = status = status_str = percent = base = ""
+
+        if line.startswith('pm'):
+            try:
+                (status, pkgname, percent, status_str) = line.split(":", 3)
+            except ValueError:
+                # silently ignore lines that can't be parsed
+                return
+        elif line.startswith('status'):
+            try:
+                (base, pkgname, status, status_str) = line.split(":", 3)
+            except ValueError:
+                (base, pkgname, status) = line.split(":", 2)
+        elif line.startswith('processing'):
+            (status, status_str, pkgname) = line.split(":", 2)
+            self.processing(pkgname.strip(), status_str.strip())
+
+        # Always strip the status message
+        pkgname = pkgname.strip()
+        status_str = status_str.strip()
+        status = status.strip()
+
+        if status == 'pmerror' or status == 'error':
+            self.error(pkgname, status_str)
+        elif status == 'conffile-prompt' or status == 'pmconffile':
+            match = re.match("\\s*\'(.*)\'\\s*\'(.*)\'.*", status_str)
+            if match:
+                self.conffile(match.group(1), match.group(2))
+        elif status == "pmstatus":
+            # FIXME: Float comparison
+            if float(percent) != self.percent or status_str != self.status:
+                self.status_change(pkgname, float(percent), status_str.strip())
+                self.percent = float(percent)
+                self.status = status_str.strip()
+        elif base == "status":
+            self.dpkg_status_change(pkgname, status)
+
+    def wait_child(self):
+        # type: () -> int
+        """Wait for child progress to exit.
+
+        This method is responsible for calling update_interface() from time to
+        time. It exits once the child has exited. The return values is the
+        full status returned from os.waitpid() (not only the return code).
+        """
+        (pid, res) = (0, 0)
+        while True:
+            try:
+                select.select([self.status_stream], [], [],
+                              self.select_timeout)
+            except select.error as error:
+                (errno_, _errstr) = error.args
+                if errno_ != errno.EINTR:
+                    raise
+
+            self.update_interface()
+            try:
+                (pid, res) = os.waitpid(self.child_pid, os.WNOHANG)
+                if pid == self.child_pid:
+                    break
+            except OSError as err:
+                if err.errno == errno.ECHILD:
+                    break
+                if err.errno != errno.EINTR:
+                    raise
+
+        return res
+
+
+class OpProgress(object):
+    """Monitor objects for operations.
+
+    Display the progress of operations such as opening the cache."""
+
+    major_change, op, percent, subop = False, "", 0.0, ""
+
+    def update(self, percent=None):
+        # type: (Optional[float]) -> None
+        """Called periodically to update the user interface.
+
+        You may use the optional argument 'percent' to set the attribute
+        'percent' in this call.
+        """
+        if percent is not None:
+            self.percent = percent
+
+    def done(self):
+        # type: () -> None
+        """Called once an operation has been completed."""

build/lib.linux-x86_64-cpython-310/apt/progress/text.py

@@ -0,0 +1,293 @@
+# Copyright (c) 2009 Julian Andres Klode <[email protected]>
+#
+# 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
+"""Progress reporting for text interfaces."""
+from __future__ import print_function
+
+import io
+import os
+import signal
+import sys
+
+import types
+from typing import Callable, Optional, Union
+
+
+import apt_pkg
+from apt.progress import base
+
+
+__all__ = ['AcquireProgress', 'CdromProgress', 'OpProgress']
+
+
+def _(msg):
+    # type: (str) -> str
+    """Translate the message, also try apt if translation is missing."""
+    res = apt_pkg.gettext(msg)
+    if res == msg:
+        res = apt_pkg.gettext(msg, "apt")
+    return res
+
+
+class TextProgress(object):
+    """Internal Base class for text progress classes."""
+
+    def __init__(self, outfile=None):
+        # type: (Optional[io.TextIOBase]) -> None
+        self._file = outfile or sys.stdout
+        self._width = 0
+
+    def _write(self, msg, newline=True, maximize=False):
+        # type: (str, bool, bool) -> None
+        """Write the message on the terminal, fill remaining space."""
+        self._file.write("\r")
+        self._file.write(msg)
+
+        # Fill remaining stuff with whitespace
+        if self._width > len(msg):
+            self._file.write((self._width - len(msg)) * ' ')
+        elif maximize:  # Needed for OpProgress.
+            self._width = max(self._width, len(msg))
+        if newline:
+            self._file.write("\n")
+        else:
+            #self._file.write("\r")
+            self._file.flush()
+
+
+class OpProgress(base.OpProgress, TextProgress):
+    """Operation progress reporting.
+
+    This closely resembles OpTextProgress in libapt-pkg.
+    """
+
+    def __init__(self, outfile=None):
+        # type: (Optional[io.TextIOBase]) -> None
+        TextProgress.__init__(self, outfile)
+        base.OpProgress.__init__(self)
+        self.old_op = ""
+
+    def update(self, percent=None):
+        # type: (Optional[float]) -> None
+        """Called periodically to update the user interface."""
+        base.OpProgress.update(self, percent)
+        if self.major_change and self.old_op:
+            self._write(self.old_op)
+        self._write("%s... %i%%\r" % (self.op, self.percent), False, True)
+        self.old_op = self.op
+
+    def done(self):
+        # type: () -> None
+        """Called once an operation has been completed."""
+        base.OpProgress.done(self)
+        if self.old_op:
+            self._write(_("%c%s... Done") % ('\r', self.old_op), True, True)
+        self.old_op = ""
+
+
+class AcquireProgress(base.AcquireProgress, TextProgress):
+    """AcquireProgress for the text interface."""
+
+    def __init__(self, outfile=None):
+        # type: (Optional[io.TextIOBase]) -> None
+        TextProgress.__init__(self, outfile)
+        base.AcquireProgress.__init__(self)
+        self._signal = None  # type: Union[Callable[[int, Optional[types.FrameType]], None], int, signal.Handlers, None] # noqa
+        self._width = 80
+        self._id = 1
+
+    def start(self):
+        # type: () -> None
+        """Start an Acquire progress.
+
+        In this case, the function sets up a signal handler for SIGWINCH, i.e.
+        window resize signals. And it also sets id to 1.
+        """
+        base.AcquireProgress.start(self)
+        self._signal = signal.signal(signal.SIGWINCH, self._winch)
+        # Get the window size.
+        self._winch()
+        self._id = 1
+
+    def _winch(self, *dummy):
+        # type: (object) -> None
+        """Signal handler for window resize signals."""
+        if hasattr(self._file, "fileno") and os.isatty(self._file.fileno()):
+            import fcntl
+            import termios
+            import struct
+            buf = fcntl.ioctl(self._file, termios.TIOCGWINSZ, 8 * b' ')  # noqa
+            dummy, col, dummy, dummy = struct.unpack('hhhh', buf)
+            self._width = col - 1  # 1 for the cursor
+
+    def ims_hit(self, item):
+        # type: (apt_pkg.AcquireItemDesc) -> None
+        """Called when an item is update (e.g. not modified on the server)."""
+        base.AcquireProgress.ims_hit(self, item)
+        line = _('Hit ') + item.description
+        if item.owner.filesize:
+            line += ' [%sB]' % apt_pkg.size_to_str(item.owner.filesize)
+        self._write(line)
+
+    def fail(self, item):
+        # type: (apt_pkg.AcquireItemDesc) -> None
+        """Called when an item is failed."""
+        base.AcquireProgress.fail(self, item)
+        if item.owner.status == item.owner.STAT_DONE:
+            self._write(_("Ign ") + item.description)
+        else:
+            self._write(_("Err ") + item.description)
+            self._write("  %s" % item.owner.error_text)
+
+    def fetch(self, item):
+        # type: (apt_pkg.AcquireItemDesc) -> None
+        """Called when some of the item's data is fetched."""
+        base.AcquireProgress.fetch(self, item)
+        # It's complete already (e.g. Hit)
+        if item.owner.complete:
+            return
+        item.owner.id = self._id
+        self._id += 1
+        line = _("Get:") + "%s %s" % (item.owner.id, item.description)
+        if item.owner.filesize:
+            line += (" [%sB]" % apt_pkg.size_to_str(item.owner.filesize))
+
+        self._write(line)
+
+    def pulse(self, owner):
+        # type: (apt_pkg.Acquire) -> bool
+        """Periodically invoked while the Acquire process is underway.
+
+        Return False if the user asked to cancel the whole Acquire process."""
+        base.AcquireProgress.pulse(self, owner)
+        # only show progress on a tty to not clutter log files etc
+        if (hasattr(self._file, "fileno") and
+                not os.isatty(self._file.fileno())):
+            return True
+
+        # calculate progress
+        percent = (((self.current_bytes + self.current_items) * 100.0) /
+                        float(self.total_bytes + self.total_items))
+
+        shown = False
+        tval = '%i%%' % percent
+        end = ""
+        if self.current_cps:
+            eta = int(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))
+
+        for worker in owner.workers:
+            val = ''
+            if not worker.current_item:
+                if worker.status:
+                    val = ' [%s]' % worker.status
+                    if len(tval) + len(val) + len(end) >= self._width:
+                        break
+                    tval += val
+                    shown = True
+                continue
+            shown = True
+
+            if worker.current_item.owner.id:
+                val += " [%i %s" % (worker.current_item.owner.id,
+                                    worker.current_item.shortdesc)
+            else:
+                val += ' [%s' % worker.current_item.description
+            if worker.current_item.owner.active_subprocess:
+                val += ' %s' % worker.current_item.owner.active_subprocess
+
+            val += ' %sB' % apt_pkg.size_to_str(worker.current_size)
+
+            # Add the total size and percent
+            if worker.total_size and not worker.current_item.owner.complete:
+                val += "/%sB %i%%" % (
+                    apt_pkg.size_to_str(worker.total_size),
+                    worker.current_size * 100.0 / worker.total_size)
+
+            val += ']'
+
+            if len(tval) + len(val) + len(end) >= self._width:
+                # Display as many items as screen width
+                break
+            else:
+                tval += val
+
+        if not shown:
+            tval += _(" [Working]")
+
+        if self.current_cps:
+            tval += (self._width - len(end) - len(tval)) * ' ' + end
+
+        self._write(tval, False)
+        return True
+
+    def media_change(self, medium, drive):
+        # type: (str, str) -> bool
+        """Prompt the user to change the inserted removable media."""
+        base.AcquireProgress.media_change(self, medium, drive)
+        self._write(_("Media change: please insert the disc labeled\n"
+                      " '%s'\n"
+                      "in the drive '%s' and press enter\n") % (medium, drive))
+        return input() not in ('c', 'C')
+
+    def stop(self):
+        # type: () -> None
+        """Invoked when the Acquire process stops running."""
+        base.AcquireProgress.stop(self)
+        # Trick for getting a translation from apt
+        self._write((_("Fetched %sB in %s (%sB/s)\n") % (
+                    apt_pkg.size_to_str(self.fetched_bytes),
+                    apt_pkg.time_to_str(self.elapsed_time),
+                    apt_pkg.size_to_str(self.current_cps))).rstrip("\n"))
+
+        # Delete the signal again.
+        import signal
+        signal.signal(signal.SIGWINCH, self._signal)
+
+
+class CdromProgress(base.CdromProgress, TextProgress):
+    """Text CD-ROM progress."""
+
+    def ask_cdrom_name(self):
+        # type: () -> Optional[str]
+        """Ask the user to provide a name for the disc."""
+        base.CdromProgress.ask_cdrom_name(self)
+        self._write(_("Please provide a name for this medium, such as "
+                      "'Debian 2.1r1 Disk 1'"), False)
+        try:
+            return str(input(":"))
+        except KeyboardInterrupt:
+            return None
+
+    def update(self, text, current):
+        # type: (str, int) -> None
+        """Set the current progress."""
+        base.CdromProgress.update(self, text, current)
+        if text:
+            self._write(text, False)
+
+    def change_cdrom(self):
+        # type: () -> bool
+        """Ask the user to change the CD-ROM."""
+        base.CdromProgress.change_cdrom(self)
+        self._write(_("Please insert an installation medium and press enter"),
+                    False)
+        try:
+            return bool(input() == '')
+        except KeyboardInterrupt:
+            return False

build/lib.linux-x86_64-cpython-310/apt/utils.py

@@ -0,0 +1,99 @@
+# Copyright (C) 2009 Canonical
+#
+# Authors:
+#  Michael Vogt
+#
+#  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.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+from __future__ import print_function
+
+import datetime
+import os
+
+from typing import Optional, Tuple
+
+import apt
+import apt_pkg
+
+
+def get_maintenance_end_date(release_date, m_months):
+    # type: (datetime.datetime, int) -> Tuple[int, int]
+    """
+    get the (year, month) tuple when the maintenance for the distribution
+    ends. Needs the data of the release and the number of months that
+    its is supported as input
+    """
+    # calc end date
+    years = m_months // 12
+    months = m_months % 12
+    support_end_year = (release_date.year + years +
+                        (release_date.month + months) // 12)
+    support_end_month = (release_date.month + months) % 12
+    # special case: this happens when e.g. doing 2010-06 + 18 months
+    if support_end_month == 0:
+        support_end_month = 12
+        support_end_year -= 1
+    return (support_end_year, support_end_month)
+
+
+def get_release_date_from_release_file(path):
+    # type: (str) -> Optional[int]
+    """
+    return the release date as time_t for the given release file
+    """
+    if not path or not os.path.exists(path):
+        return None
+
+    with os.fdopen(apt_pkg.open_maybe_clear_signed_file(path)) as data:
+        tag = apt_pkg.TagFile(data)
+        section = next(tag)
+        if "Date" not in section:
+            return None
+        date = section["Date"]
+        return apt_pkg.str_to_time(date)
+
+
+def get_release_filename_for_pkg(cache, pkgname, label, release):
+    # type: (apt.Cache, str, str, str) -> Optional[str]
+    " get the release file that provides this pkg "
+    if pkgname not in cache:
+        return None
+    pkg = cache[pkgname]
+    ver = None
+    # look for the version that comes from the repos with
+    # the given label and origin
+    for aver in pkg._pkg.version_list:
+        if aver is None or aver.file_list is None:
+            continue
+        for ver_file, _index in aver.file_list:
+            # print verFile
+            if (ver_file.origin == label and
+                    ver_file.label == label and
+                    ver_file.archive == release):
+                ver = aver
+    if not ver:
+        return None
+    indexfile = cache._list.find_index(ver.file_list[0][0])
+    for metaindex in cache._list.list:
+        for m in metaindex.index_files:
+            if (indexfile and
+                    indexfile.describe == m.describe and
+                    indexfile.is_trusted):
+                dirname = apt_pkg.config.find_dir("Dir::State::lists")
+                for relfile in ['InRelease', 'Release']:
+                    name = (apt_pkg.uri_to_filename(metaindex.uri) +
+                            "dists_%s_%s" % (metaindex.dist, relfile))
+                    if os.path.exists(dirname + name):
+                        return dirname + name
+    return None

build/lib.linux-x86_64-cpython-310/apt_pkg.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e286d7b1d0eef9ff2bad33d6c7344a1f37178a8acaf77afeeccc60ab23cb5496
+size 3906184

build/lib.linux-x86_64-cpython-310/aptsources/__init__.py

@@ -0,0 +1,9 @@
+from __future__ import print_function
+
+import apt_pkg
+
+
+# init the package system, but do not re-initialize config
+if "APT" not in apt_pkg.config:
+    apt_pkg.init_config()
+apt_pkg.init_system()

build/lib.linux-x86_64-cpython-310/aptsources/distinfo.py

@@ -0,0 +1,393 @@
+#  distinfo.py - provide meta information for distro repositories
+#
+#  Copyright (c) 2005 Gustavo Noronha Silva <[email protected]>
+#  Copyright (c) 2006-2007 Sebastian Heinlein <[email protected]>
+#
+#  Authors: Gustavo Noronha Silva <[email protected]>
+#           Sebastian Heinlein <[email protected]>
+#
+#  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
+
+from __future__ import print_function
+
+import csv
+import errno
+import logging
+import os
+from subprocess import Popen, PIPE
+import re
+
+import apt_pkg
+
+from apt_pkg import gettext as _
+
+
+def _expand_template(template, csv_path):
+    """Expand the given template.
+
+    A template file consists of a header, followed by paragraphs
+    of templated suites, followed by a footer. A templated suite
+    is any paragraph where the Suite field contains {.
+
+    This function expands all templated suites using the information
+    found in the CSV file supplied by distro-info-data.
+
+    It yields lines of template info.
+    """
+
+    known_suites = set()
+
+    # Copy out any header, and gather all hardcoded suites
+    with apt_pkg.TagFile(template) as tmpl:
+        for section in tmpl:
+            if "X-Exclude-Suites" in section:
+                known_suites.update(section["X-Exclude-Suites"].split(", "))
+            if "Suite" in section:
+                if "{" in section["Suite"]:
+                    break
+
+                known_suites.add(section["Suite"])
+
+            yield from str(section).splitlines()
+        else:
+            # We did not break, so we did copy all of them
+            return
+
+        for section in tmpl:
+            if "Suite" in section:
+                known_suites.add(section["Suite"])
+
+    with open(csv_path) as csv_object:
+        releases = reversed(list(csv.DictReader(csv_object)))
+
+    # Perform template substitution on the middle of the list
+    for rel in releases:
+        if rel["series"] in known_suites:
+            continue
+        yield ""
+        rel["version"] = rel["version"].replace(" LTS", "")
+        with apt_pkg.TagFile(template) as tmpl:
+            for section in tmpl:
+                # Only work on template sections, this skips head and tails
+                if "Suite" not in section or "{" not in section["Suite"]:
+                    continue
+                if "X-Version" in section:
+                    # Version requirements. Maybe should be made nicer
+                    ver = rel["version"]
+                    if any(
+                            (field.startswith("le") and
+                             apt_pkg.version_compare(field[3:], ver) < 0) or
+                            (field.startswith("ge") and
+                             apt_pkg.version_compare(field[3:], ver) > 0)
+                            for field in section["X-Version"].split(", ")):
+                        continue
+
+                for line in str(section).format(**rel).splitlines():
+                    if line.startswith("X-Version"):
+                        continue
+                    yield line
+
+    # Copy out remaining suites
+    with apt_pkg.TagFile(template) as tmpl:
+        # Skip the head again, we don't want to copy it twice
+        for section in tmpl:
+            if "Suite" in section and "{" in section["Suite"]:
+                break
+
+        for section in tmpl:
+            # Ignore any template parts and copy the rest out,
+            # this is the inverse of the template substitution loop
+            if "Suite" in section and "{" in section["Suite"]:
+                continue
+
+            yield from str(section).splitlines()
+
+
+class Template(object):
+
+    def __init__(self):
+        self.name = None
+        self.child = False
+        self.parents = []          # ref to parent template(s)
+        self.match_name = None
+        self.description = None
+        self.base_uri = None
+        self.type = None
+        self.components = []
+        self.children = []
+        self.match_uri = None
+        self.mirror_set = {}
+        self.distribution = None
+        self.available = True
+        self.official = True
+
+    def has_component(self, comp):
+        ''' Check if the distribution provides the given component '''
+        return comp in (c.name for c in self.components)
+
+    def is_mirror(self, url):
+        ''' Check if a given url of a repository is a valid mirror '''
+        proto, hostname, dir = split_url(url)
+        if hostname in self.mirror_set:
+            return self.mirror_set[hostname].has_repository(proto, dir)
+        else:
+            return False
+
+
+class Component(object):
+
+    def __init__(self, name, desc=None, long_desc=None, parent_component=None):
+        self.name = name
+        self.description = desc
+        self.description_long = long_desc
+        self.parent_component = parent_component
+
+    def get_parent_component(self):
+        return self.parent_component
+
+    def set_parent_component(self, parent):
+        self.parent_component = parent
+
+    def get_description(self):
+        if self.description_long is not None:
+            return self.description_long
+        elif self.description is not None:
+            return self.description
+        else:
+            return None
+
+    def set_description(self, desc):
+        self.description = desc
+
+    def set_description_long(self, desc):
+        self.description_long = desc
+
+    def get_description_long(self):
+        return self.description_long
+
+
+class Mirror(object):
+    ''' Storage for mirror related information '''
+
+    def __init__(self, proto, hostname, dir, location=None):
+        self.hostname = hostname
+        self.repositories = []
+        self.add_repository(proto, dir)
+        self.location = location
+
+    def add_repository(self, proto, dir):
+        self.repositories.append(Repository(proto, dir))
+
+    def get_repositories_for_proto(self, proto):
+        return [r for r in self.repositories if r.proto == proto]
+
+    def has_repository(self, proto, dir):
+        if dir is None:
+            return False
+        for r in self.repositories:
+            if r.proto == proto and dir in r.dir:
+                return True
+        return False
+
+    def get_repo_urls(self):
+        return [r.get_url(self.hostname) for r in self.repositories]
+
+    def get_location(self):
+        return self.location
+
+    def set_location(self, location):
+        self.location = location
+
+
+class Repository(object):
+
+    def __init__(self, proto, dir):
+        self.proto = proto
+        self.dir = dir
+
+    def get_info(self):
+        return self.proto, self.dir
+
+    def get_url(self, hostname):
+        return "%s://%s/%s" % (self.proto, hostname, self.dir)
+
+
+def split_url(url):
+    ''' split a given URL into the protocoll, the hostname and the dir part '''
+    split = re.split(":*\\/+", url, maxsplit=2)
+    while len(split) < 3:
+        split.append(None)
+    return split
+
+
+class DistInfo(object):
+
+    def __init__(self, dist=None, base_dir="/usr/share/python-apt/templates"):
+        self.metarelease_uri = ''
+        self.templates = []
+        self.arch = apt_pkg.config.find("APT::Architecture")
+
+        location = None
+        match_loc = re.compile(r"^#LOC:(.+)$")
+        match_mirror_line = re.compile(
+            r"^(#LOC:.+)|(((http)|(ftp)|(rsync)|(file)|(mirror)|(https))://"
+            r"[A-Za-z0-9/\.:\-_@]+)$")
+        #match_mirror_line = re.compile(r".+")
+
+        if not dist:
+            try:
+                dist = Popen(["lsb_release", "-i", "-s"],
+                             universal_newlines=True,
+                             stdout=PIPE).communicate()[0].strip()
+            except (OSError, IOError) as exc:
+                if exc.errno != errno.ENOENT:
+                    logging.warning(
+                        'lsb_release failed, using defaults:' % exc)
+                dist = "Debian"
+
+        self.dist = dist
+
+        map_mirror_sets = {}
+
+        dist_fname = "%s/%s.info" % (base_dir, dist)
+        csv_fname = "/usr/share/distro-info/{}.csv".format(dist.lower())
+
+        template = None
+        component = None
+        for line in _expand_template(dist_fname, csv_fname):
+            tokens = line.split(':', 1)
+            if len(tokens) < 2:
+                continue
+            field = tokens[0].strip()
+            value = tokens[1].strip()
+            if field == 'ChangelogURI':
+                self.changelogs_uri = _(value)
+            elif field == 'MetaReleaseURI':
+                self.metarelease_uri = value
+            elif field == 'Suite':
+                self.finish_template(template, component)
+                component = None
+                template = Template()
+                template.name = value
+                template.distribution = dist
+                template.match_name = "^%s$" % value
+            elif field == 'MatchName':
+                template.match_name = value
+            elif field == 'ParentSuite':
+                template.child = True
+                for nanny in self.templates:
+                    # look for parent and add back ref to it
+                    if nanny.name == value:
+                        template.parents.append(nanny)
+                        nanny.children.append(template)
+            elif field == 'Available':
+                template.available = apt_pkg.string_to_bool(value)
+            elif field == 'Official':
+                template.official = apt_pkg.string_to_bool(value)
+            elif field == 'RepositoryType':
+                template.type = value
+            elif field == 'BaseURI' and not template.base_uri:
+                template.base_uri = value
+            elif field == 'BaseURI-%s' % self.arch:
+                template.base_uri = value
+            elif field == 'MatchURI' and not template.match_uri:
+                template.match_uri = value
+            elif field == 'MatchURI-%s' % self.arch:
+                template.match_uri = value
+            elif (field == 'MirrorsFile' or
+                  field == 'MirrorsFile-%s' % self.arch):
+                # Make the path absolute.
+                value = os.path.isabs(value) and value or \
+                        os.path.abspath(os.path.join(base_dir, value))
+                if value not in map_mirror_sets:
+                    mirror_set = {}
+                    try:
+                        with open(value) as value_f:
+                            mirror_data = list(filter(
+                                match_mirror_line.match,
+                                [x.strip() for x in value_f]))
+                    except Exception:
+                        print("WARNING: Failed to read mirror file")
+                        mirror_data = []
+                    for line in mirror_data:
+                        if line.startswith("#LOC:"):
+                            location = match_loc.sub(r"\1", line)
+                            continue
+                        (proto, hostname, dir) = split_url(line)
+                        if hostname in mirror_set:
+                            mirror_set[hostname].add_repository(proto, dir)
+                        else:
+                            mirror_set[hostname] = Mirror(
+                                proto, hostname, dir, location)
+                    map_mirror_sets[value] = mirror_set
+                template.mirror_set = map_mirror_sets[value]
+            elif field == 'Description':
+                template.description = _(value)
+            elif field == 'Component':
+                if (component and not
+                        template.has_component(component.name)):
+                    template.components.append(component)
+                component = Component(value)
+            elif field == 'CompDescription':
+                component.set_description(_(value))
+            elif field == 'CompDescriptionLong':
+                component.set_description_long(_(value))
+            elif field == 'ParentComponent':
+                component.set_parent_component(value)
+        self.finish_template(template, component)
+        template = None
+        component = None
+
+    def finish_template(self, template, component):
+        " finish the current tempalte "
+        if not template:
+            return
+        # reuse some properties of the parent template
+        if template.match_uri is None and template.child:
+            for t in template.parents:
+                if t.match_uri:
+                    template.match_uri = t.match_uri
+                    break
+        if template.mirror_set == {} and template.child:
+            for t in template.parents:
+                if t.match_uri:
+                    template.mirror_set = t.mirror_set
+                    break
+        if component and not template.has_component(component.name):
+            template.components.append(component)
+            component = None
+        # the official attribute is inherited
+        for t in template.parents:
+            template.official = t.official
+        self.templates.append(template)
+
+
+if __name__ == "__main__":
+    d = DistInfo("Ubuntu", "/usr/share/python-apt/templates")
+    logging.info(d.changelogs_uri)
+    for template in d.templates:
+        logging.info("\nSuite: %s" % template.name)
+        logging.info("Desc: %s" % template.description)
+        logging.info("BaseURI: %s" % template.base_uri)
+        logging.info("MatchURI: %s" % template.match_uri)
+        if template.mirror_set != {}:
+            logging.info("Mirrors: %s" % list(template.mirror_set.keys()))
+        for comp in template.components:
+            logging.info(" %s -%s -%s" % (comp.name,
+                                          comp.description,
+                                          comp.description_long))
+        for child in template.children:
+            logging.info("  %s" % child.description)