Drop unused patches

Signed-off-by: Mubashshir <ahm@jadupc.com>

1 files changed, 0 insertions, 2068 deletions

diff --git a/debian/patches/drop_pkcompat.patch b/debian/patches/drop_pkcompat.patch
deleted file mode 100644
index 64980a7..0000000
--- a/debian/patches/drop_pkcompat.patch
+++ /dev/null
@@ -1,2068 +0,0 @@
-From: Mathieu Trudel-Lapierre <mathieu.trudel-lapierre@canonical.com>
-Subject: Drop pkcompat PackageKit compatibility module.
-
-Just use straight PackageKit.
-
----
-
----
- aptdaemon/core.py     |   12 
- aptdaemon/pkcompat.py | 2022 --------------------------------------------------
- 2 files changed, 2 insertions(+), 2032 deletions(-)
-
-Index: b/aptdaemon/core.py
-===================================================================
---- a/aptdaemon/core.py
-+++ b/aptdaemon/core.py
-@@ -1445,22 +1445,14 @@ class AptDaemon(DBusObject):
-             load_plugins = not options.disable_plugins
-             try:
-                 from .worker.pkworker import AptPackageKitWorker
--                from . import pkcompat
--            except ImportError:
--                self.worker = AptWorker(options.chroot, load_plugins)
--            else:
-                 self.worker = AptPackageKitWorker(options.chroot,
-                                                   load_plugins)
-+            except:
-+                self.worker = AptWorker(options.chroot, load_plugins)
-         self.queue = TransactionQueue(self.worker)
-         self.queue.connect("queue-changed", self._on_queue_changed)
-         # keep state of the last information about reboot required
-         self._reboot_required = self.worker.is_reboot_required()
--        try:
--            self.packagekit = pkcompat.PackageKit(self.queue, connect, bus)
--        except dbus.exceptions.NameExistsException:
--            log.warning("PackageKit is already running")
--        except NameError:
--            pass
-         log.debug("Daemon was initialized")
- 
-     def _on_queue_changed(self, queue):
-Index: b/aptdaemon/pkcompat.py
-===================================================================
---- a/aptdaemon/pkcompat.py
-+++ /dev/null
-@@ -1,2022 +0,0 @@
--# !/usr/bin/env python
--# -*- coding: utf-8 -*-
--"""
--Provides a limited compatibility layer to PackageKit
--
--Copyright (C) 2007 Ali Sabil <ali.sabil@gmail.com>
--Copyright (C) 2007 Tom Parker <palfrey@tevp.net>
--Copyright (C) 2008-2011 Sebastian Heinlein <glatzor@ubuntu.com>
--
--Licensed under the GNU General Public License Version 2
--
--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.
--"""
--
--__author__ = "Sebastian Heinlein <devel@glatzor.de>"
--
--import datetime
--import glob
--import gzip
--import locale
--import logging
--import os
--import platform
--import re
--import subprocess
--import tempfile
--import time
--import uuid
--
--from defer import inline_callbacks, return_value
--from defer.utils import dbus_deferred_method
--import dbus
--from gi.repository import GObject, GLib
--from gi.repository import PackageKitGlib as pk
--
--# for optional plugin support
--try:
--    import pkg_resources
--except ImportError:
--    pkg_resources = None
--
--from . import policykit1
--from . import core
--from .core import APTDAEMON_TRANSACTION_DBUS_INTERFACE
--from . import enums as aptd_enums
--from .errors import TransactionFailed
--from . import errors
--from .progress import DaemonAcquireProgress
--from . import worker
--from . import networking
--from .pkutils import (bitfield_summarize, bitfield_add, bitfield_remove,
--                      bitfield_contains)
--from .utils import split_package_id
--
--
--pklog = logging.getLogger("AptDaemon.PackageKit")
--
--# Check if update-manager-core is installed to get aware of the
--# latest distro releases
--try:
--    from UpdateManager.Core.MetaRelease import MetaReleaseCore
--except ImportError:
--    META_RELEASE_SUPPORT = False
--else:
--    META_RELEASE_SUPPORT = True
--
--PACKAGEKIT_DBUS_INTERFACE = "org.freedesktop.PackageKit"
--PACKAGEKIT_DBUS_SERVICE = "org.freedesktop.PackageKit"
--PACKAGEKIT_DBUS_PATH = "/org/freedesktop/PackageKit"
--
--PACKAGEKIT_TRANS_DBUS_INTERFACE = "org.freedesktop.PackageKit.Transaction"
--PACKAGEKIT_TRANS_DBUS_SERVICE = "org.freedesktop.PackageKit.Transaction"
--
--MAP_EXIT_ENUM = {
--    aptd_enums.EXIT_SUCCESS: pk.ExitEnum.SUCCESS,
--    aptd_enums.EXIT_CANCELLED: pk.ExitEnum.CANCELLED,
--    aptd_enums.EXIT_FAILED: pk.ExitEnum.FAILED,
--    aptd_enums.EXIT_FAILED: pk.ExitEnum.FAILED,
--    aptd_enums.EXIT_PREVIOUS_FAILED: pk.ExitEnum.FAILED}
--
--MAP_STATUS_ENUM = {
--    aptd_enums.STATUS_AUTHENTICATING: pk.StatusEnum.WAITING_FOR_AUTH,
--    aptd_enums.STATUS_SETTING_UP: pk.StatusEnum.SETUP,
--    aptd_enums.STATUS_QUERY: pk.StatusEnum.QUERY,
--    aptd_enums.STATUS_WAITING: pk.StatusEnum.WAIT,
--    aptd_enums.STATUS_RUNNING: pk.StatusEnum.RUNNING,
--    aptd_enums.STATUS_CANCELLING: pk.StatusEnum.CANCEL,
--    aptd_enums.STATUS_CLEANING_UP: pk.StatusEnum.CLEANUP,
--    aptd_enums.STATUS_COMMITTING: pk.StatusEnum.COMMIT,
--    aptd_enums.STATUS_DOWNLOADING: pk.StatusEnum.DOWNLOAD,
--    aptd_enums.STATUS_DOWNLOADING_REPO: pk.StatusEnum.DOWNLOAD_REPOSITORY,
--    aptd_enums.STATUS_FINISHED: pk.StatusEnum.FINISHED,
--    aptd_enums.STATUS_LOADING_CACHE: pk.StatusEnum.LOADING_CACHE,
--    aptd_enums.STATUS_RESOLVING_DEP: pk.StatusEnum.DEP_RESOLVE,
--    aptd_enums.STATUS_RUNNING: pk.StatusEnum.RUNNING,
--    aptd_enums.STATUS_WAITING_LOCK: pk.StatusEnum.WAITING_FOR_LOCK,
--    aptd_enums.STATUS_WAITING_MEDIUM: pk.StatusEnum.UNKNOWN,
--    aptd_enums.STATUS_WAITING_CONFIG_FILE_PROMPT: pk.StatusEnum.UNKNOWN}
--
--MAP_ERROR_ENUM = {
--    aptd_enums.ERROR_CACHE_BROKEN: pk.ErrorEnum.NO_CACHE,
--    aptd_enums.ERROR_DEP_RESOLUTION_FAILED: (
--        pk.ErrorEnum.DEP_RESOLUTION_FAILED),
--    aptd_enums.ERROR_INCOMPLETE_INSTALL: pk.ErrorEnum.NO_CACHE,
--    aptd_enums.ERROR_INVALID_PACKAGE_FILE: (
--        pk.ErrorEnum.PACKAGE_CORRUPT),
--    aptd_enums.ERROR_KEY_NOT_INSTALLED: pk.ErrorEnum.GPG_FAILURE,
--    aptd_enums.ERROR_KEY_NOT_REMOVED: pk.ErrorEnum.GPG_FAILURE,
--    aptd_enums.ERROR_NOT_REMOVE_ESSENTIAL_PACKAGE: (
--        pk.ErrorEnum.PACKAGE_FAILED_TO_REMOVE),
--    aptd_enums.ERROR_NO_CACHE: pk.ErrorEnum.NO_CACHE,
--    aptd_enums.ERROR_NO_LOCK: pk.ErrorEnum.CANNOT_GET_LOCK,
--    aptd_enums.ERROR_NO_PACKAGE: pk.ErrorEnum.PACKAGE_NOT_FOUND,
--    aptd_enums.ERROR_PACKAGE_ALREADY_INSTALLED: (
--        pk.ErrorEnum.PACKAGE_ALREADY_INSTALLED),
--    aptd_enums.ERROR_PACKAGE_DOWNLOAD_FAILED: (
--        pk.ErrorEnum.PACKAGE_DOWNLOAD_FAILED),
--    aptd_enums.ERROR_PACKAGE_MANAGER_FAILED: (
--        pk.ErrorEnum.TRANSACTION_ERROR),
--    aptd_enums.ERROR_PACKAGE_NOT_INSTALLED: (
--        pk.ErrorEnum.PACKAGE_NOT_INSTALLED),
--    aptd_enums.ERROR_PACKAGE_UNAUTHENTICATED: (
--        pk.ErrorEnum.BAD_GPG_SIGNATURE),
--    aptd_enums.ERROR_PACKAGE_UPTODATE: (
--        pk.ErrorEnum.NO_PACKAGES_TO_UPDATE),
--    aptd_enums.ERROR_REPO_DOWNLOAD_FAILED: (
--        pk.ErrorEnum.REPO_NOT_AVAILABLE),
--    aptd_enums.ERROR_UNREADABLE_PACKAGE_FILE: (
--        pk.ErrorEnum.INVALID_PACKAGE_FILE),
--    aptd_enums.ERROR_SYSTEM_ALREADY_UPTODATE: (
--        pk.ErrorEnum.NO_PACKAGES_TO_UPDATE),
--    aptd_enums.ERROR_NOT_AUTHORIZED: pk.ErrorEnum.NOT_AUTHORIZED,
--    aptd_enums.ERROR_AUTH_FAILED: pk.ErrorEnum.NOT_AUTHORIZED}
--
--MAP_PACKAGE_ENUM = {
--    aptd_enums.PKG_CONFIGURING: pk.InfoEnum.INSTALLING,
--    aptd_enums.PKG_DISAPPEARING: pk.InfoEnum.UNKNOWN,
--    aptd_enums.PKG_INSTALLED: pk.InfoEnum.FINISHED,
--    aptd_enums.PKG_INSTALLING: pk.InfoEnum.INSTALLING,
--    aptd_enums.PKG_PREPARING_INSTALL: pk.InfoEnum.PREPARING,
--    aptd_enums.PKG_PREPARING_PURGE: pk.InfoEnum.PREPARING,
--    aptd_enums.PKG_PREPARING_REMOVE: pk.InfoEnum.PREPARING,
--    aptd_enums.PKG_PURGED: pk.InfoEnum.FINISHED,
--    aptd_enums.PKG_PURGING: pk.InfoEnum.REMOVING,
--    aptd_enums.PKG_REMOVED: pk.InfoEnum.FINISHED,
--    aptd_enums.PKG_REMOVING: pk.InfoEnum.REMOVING,
--    aptd_enums.PKG_RUNNING_TRIGGER: pk.InfoEnum.CLEANUP,
--    aptd_enums.PKG_UNKNOWN: pk.InfoEnum.UNKNOWN,
--    aptd_enums.PKG_UNPACKING: pk.InfoEnum.DECOMPRESSING,
--    aptd_enums.PKG_UPGRADING: pk.InfoEnum.UPDATING}
--
--MAP_POLICY = {
--    "org.freedesktop.packagekit.cancel-foreign": (
--        policykit1.PK_ACTION_CANCEL_FOREIGN),
--    "org.freedesktop.packagekit.package-install": (
--        policykit1.PK_ACTION_INSTALL_OR_REMOVE_PACKAGES),
--    "org.freedesktop.packagekit.package-install-untrusted": (
--        policykit1.PK_ACTION_INSTALL_OR_REMOVE_PACKAGES),
--    "org.freedesktop.packagekit.system-trust-signing-key": (
--        policykit1.PK_ACTION_CHANGE_REPOSITORY),
--    "org.freedesktop.packagekit.package-eula-accept": (
--        policykit1.PK_ACTION_INSTALL_OR_REMOVE_PACKAGES),
--    "org.freedesktop.packagekit.package-remove": (
--        policykit1.PK_ACTION_INSTALL_OR_REMOVE_PACKAGES),
--    "org.freedesktop.packagekit.system-update": (
--        policykit1.PK_ACTION_UPGRADE_PACKAGES),
--    "org.freedesktop.packagekit.system-sources-configure": (
--        policykit1.PK_ACTION_CHANGE_REPOSITORY),
--    "org.freedesktop.packagekit.system-sources-refresh": (
--        policykit1.PK_ACTION_UPDATE_CACHE),
--    "org.freedesktop.packagekit.system-network-proxy-configure": (
--        policykit1.PK_ACTION_SET_PROXY),
--    "org.freedesktop.packagekit.device-rebind": (
--        policykit1.PK_ACTION_INSTALL_OR_REMOVE_PACKAGES),
--    "org.freedesktop.packagekit.upgrade-system": (
--        policykit1.PK_ACTION_UPGRADE_PACKAGES),
--    "org.freedesktop.packagekit.repair-system": (
--        policykit1.PK_ACTION_INSTALL_OR_REMOVE_PACKAGES),
--    "org.freedesktop.packagekit.trigger-offline-update": (
--        policykit1.PK_ACTION_UPGRADE_PACKAGES),
--    "org.freedesktop.packagekit.clear-offline-update": (
--        policykit1.PK_ACTION_UPGRADE_PACKAGES)}
--
--
--class PackageKit(core.DBusObject):
--
--    """Provides a limited set of the PackageKit system D-Bus API."""
--
--    def __init__(self, queue, connect=True, bus=None):
--        """Initialize a new PackageKit compatibility layer.
--
--        Keyword arguments:
--        connect -- if the daemon should connect to the D-Bus (default is True)
--        bus -- the D-Bus to connect to (defaults to the system bus)
--        """
--        pklog.info("Initializing PackageKit compat layer")
--        bus_name = None
--        bus_path = None
--        if connect is True:
--            if bus is None:
--                bus = dbus.SystemBus()
--            self.bus = bus
--            bus_path = PACKAGEKIT_DBUS_PATH
--            bus_name = dbus.service.BusName(PACKAGEKIT_DBUS_SERVICE, self.bus)
--        core.DBusObject.__init__(self, bus_name, bus_path)
--        self._updates_changed_timeout_id = None
--        self._updates_changed = False
--        self.queue = queue
--        self.queue.worker.connect("transaction-done",
--                                  self._on_transaction_done)
--        self.queue.connect("queue-changed", self._on_queue_changed)
--        self._distro_id = None
--        self.netmon = networking.get_network_monitor()
--        self.netmon.connect("network-state-changed",
--                            self._on_network_state_changed)
--        self._get_network_state()
--
--    @inline_callbacks
--    def _get_network_state(self):
--        """Helper to defer the network state checking."""
--        yield self.netmon.get_network_state()
--
--    # SIGNALS
--
--    # pylint: disable-msg=C0103,C0322
--    @dbus.service.signal(dbus_interface=PACKAGEKIT_DBUS_INTERFACE,
--                         signature="")
--    def RestartSchedule(self):
--        """A system restart has been sceduled."""
--        pass
--
--    # pylint: disable-msg=C0103,C0322
--    @dbus.service.signal(dbus_interface=PACKAGEKIT_DBUS_INTERFACE,
--                         signature="as")
--    def TransactionListChanged(self, transactions):
--        """The transaction list has changed, because either a transaction
--        has finished or a new transaction created.
--
--        :param transactions: A list of transaction ID's.
--        :type transactions: as
--        """
--        pklog.debug("Emitting TransactionListChanged signal: %s", transactions)
--
--    # pylint: disable-msg=C0103,C0322
--    @dbus.service.signal(dbus_interface=PACKAGEKIT_DBUS_INTERFACE,
--                         signature="")
--    def UpdatesChanged(self):
--        """This signal is emitted when the number of updates has changed."""
--        pklog.debug("Emitting UpdatesChanged signal")
--
--    # pylint: disable-msg=C0103,C0322
--    @dbus.service.signal(dbus_interface=PACKAGEKIT_DBUS_INTERFACE,
--                         signature="")
--    def RepoListChanged(self):
--        """This signal is emitted when the repository list has changed."""
--        pass
--
--    # pylint: disable-msg=C0103,C0322
--    @dbus.service.signal(dbus_interface=PACKAGEKIT_DBUS_INTERFACE,
--                         signature="")
--    def Changed(self):
--        """This signal is emitted when a property on the interface changes."""
--        pklog.debug("Emitting PackageKit Changed()")
--
--    # METHODS
--
--    # pylint: disable-msg=C0103,C0322
--    @dbus_deferred_method(PACKAGEKIT_DBUS_INTERFACE,
--                          in_signature="s", out_signature="u",
--                          sender_keyword="sender")
--    def CanAuthorize(self, action_id, sender):
--        """Allows a client to find out if it would be allowed to authorize
--        an action.
--
--        :param action_id: The action ID, e.g.
--                org.freedesktop.packagekit.system-network-proxy-configure
--        :returns: The result, either yes, no or interactive.
--        """
--        pklog.info("CanAuthorize() was called: %s", str(action_id))
--        return self._can_authorize(action_id, sender)
--
--    @inline_callbacks
--    def _can_authorize(self, action_id, sender):
--        try:
--            action_id_aptd = MAP_POLICY[action_id]
--        except KeyError:
--            return_value(pk.AuthorizeEnum.UNKNOWN)
--        try:
--            policykit1.check_authorization_by_name(
--                self, action_id, flags=policykit1.CHECK_AUTH_NONE)
--        except policykit1.NotAuthorizedError:
--            return_value(pk.AuthorizeEnum.NO)
--        except policykit1.AuthorizationFailed:
--            # check_authorization_* behaves a little bit different if the
--            # flags are set to NONE instead of INTERACTIVE
--            return_value(pk.AuthorizeEnum.INTERACTIVE)
--        except:
--            return_value(pk.AuthorizeEnum.UNKNOWN)
--        return_value(pk.AuthorizeEnum.YES)
--
--    # pylint: disable-msg=C0103,C0322
--    @dbus.service.method(PACKAGEKIT_DBUS_INTERFACE,
--                         in_signature="s", out_signature="")
--    def StateHasChanged(self, reason):
--        """This method suggests to PackageKit that the package backend state
--        may have changed. This allows plugins to the native package manager
--        to suggest that PackageKit drops it's caches.
--
--        :param reason:
--            The reason of the state change. Valid reasons are resume or
--            posttrans. Resume is given a lower priority than posttrans.
--        """
--        pklog.info("StateHasChanged() was called: %s", str(reason))
--        self._updates_changed = True
--        if reason == "cache-update":
--            self._check_updates_changed(timeout=30)
--        elif reason == "resume":
--            self._check_updates_changed(timeout=180)
--
--    # pylint: disable-msg=C0103,C0322
--    @dbus_deferred_method(PACKAGEKIT_DBUS_INTERFACE,
--                          in_signature="", out_signature="o",
--                          sender_keyword="sender")
--    def CreateTransaction(self, sender):
--        """Gets a new transaction ID from the daemon.
--
--        :returns: The tid, e.g. 45_dafeca_checkpoint32
--        """
--        pklog.info("CreateTransaction() was called")
--        return self._create_transaction(sender)
--
--    @inline_callbacks
--    def _create_transaction(self, sender):
--        pid, uid, gid, cmdline = yield policykit1.get_proc_info_from_dbus_name(
--            sender, self.bus)
--        pktrans = PackageKitTransaction(
--            pid, uid, gid, cmdline, self.queue, sender)
--        return_value(pktrans.tid)
--
--    # pylint: disable-msg=C0103,C0322
--    @dbus.service.method(PACKAGEKIT_DBUS_INTERFACE,
--                         in_signature="", out_signature="s")
--    def GetDaemonState(self):
--        """Return the state of the currently running transactions."""
--        pklog.info("GetDaemonState() was called")
--        # FIXME: Add some useful data here
--        return "All is fine!"
--
--    # pylint: disable-msg=C0103,C0322
--    @dbus.service.method(PACKAGEKIT_DBUS_INTERFACE,
--                         in_signature="", out_signature="ao")
--    def GetTransactionList(self):
--        """Gets the transaction list of any transactions that are in
--        progress.
--
--        :returns: A list of transaction ID's
--        """
--        pklog.info("GetTransactionList() was called")
--        return self._get_transaction_list()
--
--    # HELPERS
--
--    def _get_properties(self, iface):
--        """Helper to get the properties of a D-Bus interface."""
--        if iface == PACKAGEKIT_DBUS_INTERFACE:
--            return {
--                # Claim that we are a current version
--                "VersionMajor": dbus.UInt32(0),
--                "VersionMinor": dbus.UInt32(8),
--                "VersionMicro": dbus.UInt32(9),
--                "BackendName": dbus.String("aptdaemon"),
--                "BackendDescription": dbus.String("Compatibility layer"),
--                "BackendAuthor": dbus.String(__author__),
--                "Groups": dbus.UInt64(self.queue.worker.groups),
--                "Provides": dbus.UInt64(self.queue.worker.provides),
--                "Filters": dbus.UInt64(self.queue.worker.filters),
--                "Roles": dbus.UInt64(self.queue.worker.roles),
--                "MimeTypes": dbus.Array(self.queue.worker.mime_types,
--                                        signature="s"),
--                "Locked": dbus.Boolean(False),
--                "NetworkState": dbus.UInt32(self.netmon.state),
--                "DistroId": dbus.String(self._get_distro_id())}
--        else:
--            return {}
--
--    def _get_distro_id(self):
--        """Return information about the distibution."""
--        if self._distro_id is None:
--            distro, version, _codename = platform.dist()
--            self._distro_id = "%s;%s;%s" % (distro or "unknown",
--                                            version or "unknown",
--                                            self.queue.worker.NATIVE_ARCH)
--        return self._distro_id
--
--    def _on_network_state_changed(self, mon, state):
--        self.Changed()
--        self.PropertiesChanged(PACKAGEKIT_DBUS_INTERFACE,
--                               {"NetworkState": dbus.UInt32(state)}, [])
--
--    def _on_queue_changed(self, queue):
--        self.TransactionListChanged(self._get_transaction_list())
--        self._check_updates_changed()
--
--    def _get_transaction_list(self):
--        pk_transactions = []
--        for trans in self.queue.items:
--            # We currently only emit PackageKit transaction
--            # FIXME: Should we use MergedTransaction for all transactions and
--            #       ROLE_UNKOWN for aptdaemon only transactions?
--            try:
--                pk_transactions.append(trans.pktrans.tid)
--            except AttributeError:
--                pass
--        try:
--            pk_transactions.append(self.queue.worker.trans.pktrans.tid)
--        except AttributeError:
--            pass
--        return pk_transactions
--
--    def _on_transaction_done(self, worker, trans):
--        # If a cache modifing transaction is completed schedule an
--        # UpdatesChanged signal
--        if trans.role in (aptd_enums.ROLE_INSTALL_FILE,
--                          aptd_enums.ROLE_INSTALL_PACKAGES,
--                          aptd_enums.ROLE_REMOVE_PACKAGES,
--                          aptd_enums.ROLE_UPGRADE_PACKAGES,
--                          aptd_enums.ROLE_COMMIT_PACKAGES,
--                          aptd_enums.ROLE_UPGRADE_SYSTEM,
--                          aptd_enums.ROLE_FIX_BROKEN_DEPENDS):
--            self._updates_changed = True
--            self._check_updates_changed()
--        elif trans.role == aptd_enums.ROLE_UPDATE_CACHE:
--            self._updates_changed = True
--            self._check_updates_changed(timeout=30)
--
--    def _check_updates_changed(self, timeout=60):
--        """After the queue was processed schedule a delayed UpdatesChanged
--        signal if required.
--        """
--        if not self.queue.items and self._updates_changed:
--            if self._updates_changed_timeout_id:
--                # If we already have a scheduled UpdatesChanged signal
--                # delay it even further
--                pklog.debug("UpdatesChanged signal re-scheduled")
--                GLib.source_remove(self._updates_changed_timeout_id)
--            else:
--                pklog.debug("UpdatesChanged signal scheduled")
--            self._updates_changed_timeout_id = \
--                GLib.timeout_add_seconds(timeout,
--                                         self._delayed_updates_changed)
--
--    def _delayed_updates_changed(self):
--        """Emit the UpdatesChanged signal and clear the timeout."""
--        self.UpdatesChanged()
--        self._updates_changed_timeout_id = None
--        self._updates_changed = False
--        return False
--
--
--class MergedTransaction(core.Transaction):
--
--    """Overlay of an Aptdaemon transaction which also provides the
--    PackageKit object and its interfaces.
--    """
--
--    def __init__(self, pktrans, role, queue, connect=True,
--                 bus=None, packages=None, kwargs=None):
--        core.Transaction.__init__(self, pktrans.tid[1:], role, queue,
--                                  pktrans.pid, pktrans.uid, pktrans.gid,
--                                  pktrans.cmdline, pktrans.sender,
--                                  connect, bus, packages, kwargs)
--        self.pktrans = pktrans
--        self.run_time = 0
--
--    @inline_callbacks
--    def _run(self, sender):
--        """Run the transaction and convert exceptions to PackageKit ones."""
--        try:
--            yield core.Transaction._run(self, sender)
--        except (TransactionFailed, errors.NotAuthorizedError,
--                errors.AuthorizationFailed):
--            # It is sufficient for PackageKit if the exit state and error
--            # code of the transaction are set. So silently drop the execp
--            if self.error:
--                pass
--        except Exception as error:
--            raise error
--
--    @inline_callbacks
--    def _check_auth(self):
--        """Override the auth method to allow simulates without any
--        authorization.
--        """
--        if bitfield_contains(self.pktrans.flags,
--                             pk.TransactionFlagEnum.SIMULATE):
--            raise StopIteration
--        else:
--            yield core.Transaction._check_auth(self)
--
--    @inline_callbacks
--    def _check_simulated(self):
--        """Skip simulate calls for simulated transactions."""
--        if bitfield_contains(self.pktrans.flags,
--                             pk.TransactionFlagEnum.SIMULATE):
--            raise StopIteration
--        else:
--            yield core.Transaction._check_simulated(self)
--
--    def _set_status(self, enum):
--        core.Transaction._set_status(self, enum)
--        self.pktrans.status = get_pk_status_enum(enum)
--
--    status = property(core.Transaction._get_status, _set_status)
--
--    def _set_progress(self, percent):
--        core.Transaction._set_progress(self, percent)
--        self.pktrans.percentage = self._progress
--
--    progress = property(core.Transaction._get_progress, _set_progress)
--
--    def _set_progress_details(self, details):
--        core.Transaction._set_progress_details(self, details)
--        self.pktrans.download_size_remaing = int(details[3]) - int(details[2])
--        self.pktrans.speed = int(details[4])
--        self.pktrans.remaining_time = int(details[5])
--        self.pktrans.elapsed_time = int(time.time() - self.pktrans.start_time)
--
--    progress_details = property(core.Transaction._get_progress_details,
--                                _set_progress_details)
--
--    def _set_progress_package(self, progress):
--        core.Transaction._set_progress_package(self, progress)
--        pkg_name, enum = progress
--        # Ignore dpkg triggers
--        if enum == aptd_enums.PKG_RUNNING_TRIGGER or pkg_name == "dpkg-exec":
--            return
--        try:
--            id = self.pktrans.pkg_id_cache[pkg_name]
--        except KeyError:
--            id = get_pk_package_id(pkg_name)
--        self.emit_package(get_pk_package_enum(enum), id, "")
--
--    progress_package = property(core.Transaction._get_progress_package,
--                                _set_progress_package)
--
--    def _set_progress_download(self, progress_download):
--        core.Transaction._set_progress_download(self, progress_download)
--        prog_enum = progress_download[1]
--        prog_name = progress_download[2]
--        total_size = progress_download[3]
--        partial_size = progress_download[4]
--
--        try:
--            id = self.pktrans.pkg_id_cache[prog_name]
--        except KeyError:
--            return
--        self.pktrans.Package(pk.InfoEnum.DOWNLOADING, id, "")
--        if prog_enum == aptd_enums.DOWNLOAD_IDLE:
--            percentage = 0
--        elif prog_enum == aptd_enums.DOWNLOAD_FETCHING and total_size > 0:
--            percentage = partial_size * 100 / total_size
--        elif prog_enum == aptd_enums.DOWNLOAD_DONE:
--            percentage = 100
--        else:
--            # In the case of an error
--            percentage = 0
--        self.pktrans.ItemProgress(id, pk.InfoEnum.DOWNLOADING, percentage)
--
--    progress_download = property(core.Transaction._get_progress_download,
--                                 _set_progress_download)
--
--    def _set_exit(self, enum):
--        core.Transaction._set_exit(self, enum)
--        self.pktrans.exit = get_pk_exit_enum(enum)
--
--    exit = property(core.Transaction._get_exit, _set_exit)
--
--    def _set_error(self, excep):
--        core.Transaction._set_error(self, excep)
--        self.pktrans.ErrorCode(get_pk_error_enum(excep.code),
--                               self._error_property[1])
--
--    error = property(core.Transaction._get_error, _set_error)
--
--    def _remove_from_connection_no_raise(self):
--        core.Transaction._remove_from_connection_no_raise(self)
--        if self.pktrans is None:
--            return False
--        self.pktrans.Destroy()
--        try:
--            self.pktrans.remove_from_connection()
--        except LookupError as error:
--            pklog.debug("remove_from_connection() raised LookupError: %s",
--                        error)
--        finally:
--            self.pktrans.trans = None
--            self.pktrans = None
--        return False
--
--    def emit_details(self, package_id, license, group, detail, url, size):
--        self.pktrans.Details(package_id, license, group, detail, url, size)
--
--    def emit_files(self, id, file_list):
--        self.pktrans.Files(id, file_list)
--
--    def emit_package(self, info, id, summary):
--        if id.startswith("dpkg-exec;"):
--            # PackageKit would show a non existing package
--            pklog.debug("Don't emit Package() signal for the dpkg trigger")
--            return
--        self.pktrans.Package(info, id, summary)
--        self.pktrans.last_package = id
--
--    def emit_update_detail(self, package_id, updates, obsoletes, vendor_urls,
--                           bugzilla_urls, cve_urls, restart, update_text,
--                           changelog, state, issued, updated):
--        self.pktrans.UpdateDetail(package_id, updates, obsoletes, vendor_urls,
--                                  bugzilla_urls, cve_urls, restart,
--                                  update_text, changelog, state, issued,
--                                  updated)
--
--
--class PackageKitTransaction(core.DBusObject):
--
--    """Provides a PackageKit transaction object."""
--
--    def __init__(self, pid, uid, gid, cmdline, queue, sender,
--                 connect=True, bus=None):
--        pklog.info("Initializing PackageKit transaction")
--        bus_name = None
--        bus_path = None
--        self.tid = "/%s" % uuid.uuid4().hex
--        if connect is True:
--            if bus is None:
--                bus = dbus.SystemBus()
--            self.bus = bus
--            bus_path = self.tid
--            bus_name = dbus.service.BusName(PACKAGEKIT_DBUS_SERVICE, bus)
--        core.DBusObject.__init__(self, bus_name, bus_path)
--        self.queue = queue
--        self.hints = {}
--        self.start_time = time.time()
--        self._elapsed_time = dbus.UInt32(0)
--        self._remaining_time = dbus.UInt32(0)
--        self._download_size_remaining = dbus.UInt64(0)
--        self._speed = dbus.UInt32(0)
--        self._caller_active = True
--        self._allow_cancel = False
--        self._percentage = dbus.UInt32(0)
--        self._status = pk.StatusEnum.SETUP
--        self._last_package = ""
--        self.uid = dbus.UInt32(uid)
--        self.gid = dbus.UInt32(gid)
--        self.pid = pid
--        self.cmdline = cmdline
--        self.role = pk.RoleEnum.UNKNOWN
--        self.sender = sender
--        self.trans = None
--        self.flags = pk.TransactionFlagEnum.NONE
--        self.pkg_id_cache = {}
--
--    @property
--    def allow_cancel(self):
--        return self._allow_cancel
--
--    @allow_cancel.setter
--    def allow_cancel(self, value):
--        self._allow_cancel = dbus.Boolean(value)
--        self.PropertiesChanged(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                               {"AllowCancel": self._allow_cancel}, [])
--        self.Changed()
--
--    @property
--    def last_package(self):
--        return self._last_package
--
--    @last_package.setter
--    def last_package(self, value):
--        self._last_package = dbus.String(value)
--        self.PropertiesChanged(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                               {"LastPackage": self._last_package}, [])
--        self.Changed()
--
--    @property
--    def caller_active(self):
--        return self._caller_active
--
--    @caller_active.setter
--    def caller_active(self, value):
--        self._caller_active = dbus.Boolean(value)
--        self.PropertiesChanged(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                               {"CallerActive": self._caller_active}, [])
--        self.Changed()
--
--    @property
--    def percentage(self):
--        return self._percentage
--
--    @percentage.setter
--    def percentage(self, progress):
--        self._percentage = dbus.UInt32(progress)
--        self.PropertiesChanged(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                               {"Percentage": self._percentage}, [])
--        self.Changed()
--
--    @property
--    def status(self):
--        return self._status
--
--    @status.setter
--    def status(self, enum):
--        self._status = dbus.UInt32(enum)
--        self.PropertiesChanged(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                               {"Status": self._status}, [])
--        self.Changed()
--
--    @property
--    def elapsed_time(self):
--        return self._elapsed_time
--
--    @elapsed_time.setter
--    def elapsed_time(self, ela):
--        self._elpased_time = dbus.UInt32(ela)
--        self.PropertiesChanged(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                               {"ElapsedTime": self._elapsed_time}, [])
--        self.Changed()
--
--    @property
--    def remaining_time(self):
--        return self._remaining_time
--
--    @remaining_time.setter
--    def remaining_time(self, value):
--        self._remaining_time = dbus.UInt32(value)
--        self.PropertiesChanged(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                               {"RemainingTime": self._remaining_time}, [])
--        self.Changed()
--
--    @property
--    def download_size_remaining(self):
--        return self._download_size_remaining
--
--    @download_size_remaining.setter
--    def download_size_remaining(self, value):
--        self._download_size_remaining = dbus.UInt64(value)
--        self.PropertiesChanged(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                               {"DownloadSizeRemaining":
--                                self._download_size_remaining}, [])
--        self.Changed()
--
--    @property
--    def speed(self):
--        return self._speed
--
--    @speed.setter
--    def speed(self, speed):
--        self._speed = dbus.UInt32(speed)
--        self.PropertiesChanged(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                               {"Speed": self._speed}, [])
--        self.Changed()
--
--    @property
--    def exit(self):
--        return self._exit
--
--    @exit.setter
--    def exit(self, enum):
--        self._exit = enum
--        self.run_time = int((time.time() - self.start_time) * 1000)
--        # The time could go backwards ...
--        if self.run_time < 0:
--            self.run_time = 0
--        if enum == pk.ExitEnum.CANCELLED:
--            self.ErrorCode(pk.ErrorEnum.TRANSACTION_CANCELLED, "")
--        self.status = pk.StatusEnum.FINISHED
--        self.Finished(enum, self.run_time)
--
--    # SIGNALS
--
--    # pylint: disable-msg=C0103,C0322
--    @dbus.service.signal(dbus_interface=PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                         signature="osbuusus")
--    def Transaction(self, object_path, timespec, succeeded, role, duration,
--                    data, uid, cmdline):
--        """This signal is sent when more details are required about a
--        specific transaction.
--
--        :param object_path: The transaction ID of the old transaction.
--        :param timespec: The timespec of the old transaction in ISO8601 format.
--        :param succeeded: If the transaction succeeded.
--        :param role: The role enumerated type.
--        :param duration: The duration of the transaction in milliseconds.
--        :param data: Any data associated
--        :param uid: The user ID of the user that scheduled the action.
--        :param cmdline: The command line of the tool that scheduled the action,
--            e.g. /usr/bin/gpk-application.
--        """
--        pklog.debug("Emitting Transaction signal: %s, %s, %s, %s, %s, %s, "
--                    "%s, %s", object_path, timespec, succeeded,
--                    pk.role_enum_to_string(role), duration, data, uid,
--                    cmdline)
--
--    # pylint: disable-msg=C0103,C0322
--    @dbus.service.signal(dbus_interface=PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                         signature="us")
--    def ErrorCode(self, code, details):
--        """This signal is used to report errors back to the session program.
--        Errors should only be send on fatal abort.
--
--        :param code: Enumerated type, e.g. no-network.
--        :param details: Long description or error, e.g. "failed to connect"
--
--        :type code: u
--        :type details: s
--        """
--        pklog.debug("Emitting ErrorCode signal: %s, %s",
--                    pk.error_enum_to_string(code), details)
--
--    # pylint: disable-msg=C0103,C0322
--    @dbus.service.signal(dbus_interface=PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                         signature="")
--    def Changed(self):
--        """This signal is emitted when a property on the interface changes."""
--        pklog.debug("Emitting Changed signal")
--
--    # pylint: disable-msg=C0103,C0322
--    @dbus.service.signal(dbus_interface=PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                         signature="")
--    def Destroy(self):
--        """This signal is sent when the transaction has been destroyed
--        and is no longer available for use."""
--        pklog.debug("Emitting Destroy signal")
--
--    # pylint: disable-msg=C0103,C0322
--    @dbus.service.signal(dbus_interface=PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                         signature="uu")
--    def Finished(self, exit_enum, runtime):
--        """This signal is used to signal that the transaction has finished.
--        :param exit: The PkExitEnum describing the exit status of the
--            transaction.
--        :param runtime: The amount of time in milliseconds that the
--            transaction ran for.
--
--        :type exit: s
--        :type runtime: u
--        """
--        pklog.debug("Emitting Finished signal: %s, %s",
--                    pk.exit_enum_to_string(exit_enum), runtime)
--        pass
--
--    # pylint: disable-msg=C0103,C0322
--    @dbus.service.signal(dbus_interface=PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                         signature="ssusst")
--    def Details(self, package_id, license, group, detail, url, size):
--        """This signal allows the backend to convey more details about the
--        package.
--
--        :param package_id: The package ID
--
--        :param license:
--            The license string, e.g. GPLv2+ or BSD and (MPLv1.1 or GPLv2+).
--            Moredetails about the correct way to format licensing strings can
--            be found on the Fedora packaging wiki.
--        :param group:
--            The enumerated package group description
--        :param detail:
--            The multi-line package description. If formatting is required,
--            then markdown syntax should be used, e.g. This is **critically**
--            important
--        :param url:
--            The upstream project homepage
--        :param size:
--            The size of the package in bytes. This should be the size of the
--            entire package file, not the size of the files installed on the
--            system. If the package is not installed, and already downloaded
--            and present in the package manager cache, then this value should
--            be set to zero.
--        """
--        pklog.debug("Emitting Details signal for %s", package_id)
--
--    # pylint: disable-msg=C0103,C0322
--    @dbus.service.signal(dbus_interface=PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                         signature="us")
--    def Message(self, kind, details):
--        """This signal is sent when the backend wants to send a message to
--        the session.
--
--        The message will be shown after the transaction has been completed.
--        """
--        pklog.debug("Emitting Message signal: %s, %s", kind, details)
--
--    # pylint: disable-msg=C0103,C0322
--    @dbus.service.signal(dbus_interface=PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                         signature="sas")
--    def Files(self, package_id, file_list):
--        """This signal is used to push file lists from the backend to the
--        session.
--
--        :param package_id:
--            The Package ID that called the method.
--        :param file_list:
--            The file list
--        """
--        pklog.debug("Emitting Files signal: %s, %s", package_id, file_list)
--
--    # pylint: disable-msg=C0103,C0322
--    @dbus.service.signal(dbus_interface=PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                         signature="suu")
--    def ItemProgress(self, package_id, status, percentage):
--        """This signal allows the backend to send information about
--        package or repository progress when using Simultanous mode.
--
--        :param package_id: The package ID
--        :param status:
--            The status enumerated value that is being completed
--        :param percentage:
--            The percentage of this action is completed
--        """
--        pklog.debug("Emitting ItemProgress signal for %s: %s, %s",
--                    package_id, pk.info_enum_to_string(status), percentage)
--
--    # pylint: disable-msg=C0103,C0322
--    @dbus.service.signal(dbus_interface=PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                         signature="sasasasasasussuss")
--    def UpdateDetail(self, package_id, updates, obsoletes, vendor_urls,
--                     bugzilla_urls, cve_urls, restart, update_text, changelog,
--                     state, issued, updated):
--        """This signal is sent when more details are required about a
--        specific update.
--
--        :param package_id: The package ID
--        :param updates:
--            A list of package_id's that are to be updated.
--        :param obsoletes:
--            A list of package_id's that are to be obsoleted.
--        :param vendor_urls:
--            A URL with more details on the update, e.g. a page with more
--            information on the update. The format of this command should
--            be http://www.foo.org/page.html?4567;Update to SELinux
--        :param bugzilla_urls:
--            A bugzilla URL with more details on the update. If no URL is
--            available then this field should be left empty.
--        :param cve_urls:
--            A CVE URL with more details on the security advisory.
--        :param restart:
--            A valid restart type, e.g. system.
--        :param update_text:
--            The update text describing the update. If formatting is required,
--            then markdown syntax should be used, e.g. This is **critically**
--            important.
--        :param changelog:
--            The ChangeLog text describing the changes since the last version.
--        :param state:
--            The state of the update, e.g. stable or testing.
--        :param issued:
--            The ISO8601 encoded date that the update was issued.
--        :param updated:
--            The ISO8601 encoded date that the update was updated.
--        """
--        pklog.debug("Emitting UpdateDetail signal for %s", package_id)
--
--    # pylint: disable-msg=C0103,C0322
--    @dbus.service.signal(dbus_interface=PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                         signature="uss")
--    def Package(self, info, package_id, summary):
--        """This signal allows the backend to communicate packages to the
--        session.
--
--        If updating, as packages are updated then emit them to the screen.
--        This allows a summary to be presented after the transaction.
--        When returning results from a search always return installed
--        before available for the same package name.
--
--        :param info: A valid info enumerated type
--        :param package_id: This identifier is of the form
--            name;version;arch;data in a single string and is meant to
--            represent a single package unique across all local and remote
--            data stores. For a remote, not-installed package the data
--            field should be set as the repository identifier or repository
--            name. The data field for an installed package must be prefixed
--            with installed as this is used to identify which packages are
--            installable or installed in the client tools. As a special
--            extension, if the package manager is able to track which
--            repository a package was originally installed from, then the data
--            field can be set to installed:REPO-NAME which allows the frontend
--            client to advise the user of the package origin. The data field
--            for a non-installed local package must be local as this signifies
--            a repository name is not available and that package resides
--            locally on the client system rather than in any specific
--            repository.
--        :param summary: The one line package summary, e.g. Clipart for
--            OpenOffice
--        """
--        pklog.debug("Emitting Package signal: %s, %s, %s'",
--                    pk.info_enum_to_string(info), package_id, summary[:10])
--
--    # pylint: disable-msg=C0103,C0322
--    @dbus.service.signal(dbus_interface=PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                         signature="sss")
--    def DistroUpgrade(self, distro_type, name, summary):
--        """This signal allows the backend to communicate distribution upgrades
--        to the session.
--        :param type: A valid upgrade string enumerated type, e.g. stable
--            or unstable
--        :param name: The short name of the distribution, e.g. Fedora Core
--            10 RC1
--        :param summary: The multi-line description of the release
--        """
--        pklog.debug("Emitting DistroUpgrade signal: %s, %s, %s",
--                    pk.distro_upgrade_enum_to_string(distro_type),
--                    name, summary)
--
--    # pylint: disable-msg=C0103,C0322
--    @dbus.service.signal(dbus_interface=PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                         signature="us")
--    def RequireRestart(self, restart_type, package_id):
--        """This signal is sent when the session client should notify the user
--        that a restart is required to get all changes into effect.
--
--        :param package_id:
--            The Package ID of the package tiggering the restart
--        :param file_list:
--            One of system, application or session
--        """
--        pklog.debug("Emitting RequireRestart signal: %s, %s",
--                    pk.restart_enum_to_string(restart_type), package_id)
--
--    # METHODS
--
--    # pylint: disable-msg=C0103,C0322
--    @dbus.service.method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                         in_signature="as", out_signature="")
--    def SetHints(self, hints):
--        """This method allows the calling session to set transaction hints
--        for the package manager which can change as the transaction runs.
--
--        This method can be sent before the transaction has been run or
--        whilst it is running. There is no limit to the number of times
--        this method can be sent, although some backends may only use the
--        values that were set before the transaction was started.
--
--        Each parameter value is optional.
--
--        :param hints: The values as an array of strings, for example
--            ['locale=en_GB.utf8','interactive=false','cache-age=3600']
--        """
--        pklog.info("SetHints() was called: %s", get_string_from_array(hints))
--        for hint in hints:
--            key, value = hint.split("=", 1)
--            if key not in ["locale", "idle", "background", "interactive",
--                           "cache-age", "frontend-socket"]:
--                raise Exception("Invalid option %s" % key)
--            self.hints[key] = value
--
--    # pylint: disable-msg=C0103,C0322
--    @dbus_deferred_method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                          in_signature="", out_signature="",
--                          sender_keyword="sender")
--    def Cancel(self, sender):
--        """This method cancels a transaction that is already running."""
--        if self.trans:
--            return self.trans._cancel(sender)
--
--    # pylint: disable-msg=C0103,C0322
--    @dbus_deferred_method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                          in_signature="tasbb", out_signature="",
--                          sender_keyword="sender")
--    def RemovePackages(self, flags, package_ids, allow_deps, autoremove,
--                       sender):
--        """This method removes packages from the local system.
--
--        This method typically emits Progress, Status and Error and Package.
--
--        Package enumerated types should be downloading, updating,
--        installing or removing.
--
--        :param flags: If the transaction should be simulated or prepared
--        :param package_ids: An array of package IDs.
--        :param allow_deps:
--            Either true or false. If true allow other packages to be removed
--            with the package, but false should cause the script to abort if
--            other packages are dependant on the package.
--        :param autoremove:
--            Either true or false. This option is only really interesting on
--            embedded devices with a limited amount of flash storage. It
--            suggests to the packagekit backend that dependencies installed at
--            the same time as the package should also be removed if they are not
--            required by anything else. For instance, if you install OpenOffice,
--            it might download libneon as a dependency. When auto_remove is set
--            to true, and you remove OpenOffice then libneon will also get
--            removed automatically.
--        """
--        pklog.info("RemovePackages() was called: %s, %s",
--                   get_string_from_flags(flags),
--                   get_string_from_array(package_ids))
--        return self._remove_packages(flags, package_ids, allow_deps,
--                                     autoremove, sender)
--
--    @inline_callbacks
--    def _remove_packages(self, flags, package_ids, allow_deps, autoremove,
--                         sender):
--        self.role = pk.RoleEnum.REMOVE_PACKAGES
--        self.flags = flags
--        self.trans = self._get_merged_trans(aptd_enums.ROLE_REMOVE_PACKAGES,
--                                            pkg_ids=package_ids,
--                                            pkg_type=aptd_enums.PKGS_REMOVE)
--        yield self.trans._set_property(APTDAEMON_TRANSACTION_DBUS_INTERFACE,
--                                       "RemoveObsoletedDepends", autoremove,
--                                       sender)
--        # FIXME: Implement allow_deps
--        yield self.trans._run(sender)
--
--    # pylint: disable-msg=C0103,C0322
--    @dbus_deferred_method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                          in_signature="tas", out_signature="",
--                          sender_keyword="sender")
--    def UpdatePackages(self, flags, package_ids, sender):
--        """This method updates existing packages on the local system.
--
--        The installer should always update extra packages automatically
--        to fulfil dependencies.
--
--        This should allow an application to find out what package owns a
--        file on the system.
--
--        This method typically emits Progress, Status and Error and Package.
--
--        :param flags:
--            If the transaction is only allowed to install trusted packages.
--            Unsigned packages should not be installed if the flags
--            contains ONLY_TRUSED.
--            If this method is can only install trusted packages, and
--            the packages are unsigned, then the backend will send a
--            ErrorCode(missing-gpg-signature). On recieving this error, the
--            client may choose to retry with ONLY_TRUSTED set after
--            gaining further authentication.
--        : param package_ids: An array of package IDs.
--        """
--        pklog.info("UpdatePackages() was called: %s, %s",
--                   get_string_from_flags(flags),
--                   get_string_from_array(package_ids))
--        return self._update_packages(flags, package_ids, sender)
--
--    @inline_callbacks
--    def _update_packages(self, flags, package_ids, sender):
--        self.role = pk.RoleEnum.UPDATE_PACKAGES
--        self.flags = flags
--        self.trans = self._get_merged_trans(aptd_enums.ROLE_UPGRADE_PACKAGES,
--                                            pkg_ids=package_ids,
--                                            pkg_type=aptd_enums.PKGS_UPGRADE)
--        yield self.trans._set_property(
--            APTDAEMON_TRANSACTION_DBUS_INTERFACE,
--            "AllowUnauthenticated",
--            not bitfield_contains(flags,
--                                  pk.TransactionFlagEnum.ONLY_TRUSTED),
--            sender)
--        yield self.trans._run(sender)
--
--    # pylint: disable-msg=C0103,C0322
--    @dbus_deferred_method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                          in_signature="uas", out_signature="",
--                          sender_keyword="sender")
--    def InstallPackages(self, flags, package_ids, sender):
--        """This method installs new packages on the local system.
--
--        The installer should always install extra packages automatically
--        as the use could call GetDepends prior to the install if a
--        confirmation is required in the UI.
--
--        This method typically emits Progress, Status and Error and Package.
--
--        Package enumerated types should be downloading, updating,
--        installing or removing.
--
--        :param flags:
--            If the transaction is only allowed to install trusted packages.
--            Unsigned packages should not be installed if the flags
--            contains ONLY_TRUSED.
--            If this method is can only install trusted packages, and
--            the packages are unsigned, then the backend will send a
--            ErrorCode(missing-gpg-signature). On recieving this error, the
--            client may choose to retry with ONLY_TRUSTED set after
--            gaining further authentication.
--        : param package_ids: An array of package IDs.
--        """
--        pklog.info("InstallPackages() was called: %s, %s",
--                   get_string_from_flags(flags),
--                   get_string_from_array(package_ids))
--        return self._install_packages(flags, package_ids, sender)
--
--    @inline_callbacks
--    def _install_packages(self, flags, package_ids, sender):
--        self.role = pk.RoleEnum.INSTALL_PACKAGES
--        self.flags = flags
--        self.trans = self._get_merged_trans(aptd_enums.ROLE_INSTALL_PACKAGES,
--                                            pkg_ids=package_ids,
--                                            pkg_type=aptd_enums.PKGS_INSTALL)
--        yield self.trans._set_property(
--            APTDAEMON_TRANSACTION_DBUS_INTERFACE,
--            "AllowUnauthenticated",
--            not bitfield_contains(flags,
--                                  pk.TransactionFlagEnum.ONLY_TRUSTED),
--            sender)
--        yield self.trans._run(sender)
--
--    # pylint: disable-msg=C0103,C0322
--    @dbus.service.method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                         in_signature="su", out_signature="",
--                         sender_keyword="sender")
--    def UpgradeSystem(self, distro_id, upgrade_kind, sender):
--        """This method updates existing packages on the local system.
--
--        The installer should always update extra packages automatically
--        to fulfil dependencies.
--
--        This should allow an application to find out what package owns a
--        file on the system.
--
--        This method typically emits Progress, Status and Error and Package.
--
--        :param distro_id: The distribution id to upgrade to, e.g. saucy
--        :param upgrade_kind:
--            The type of upgrade e.g. minimal, default or complete.
--            Minimal upgrades will download the smallest amount of data
--            before launching a installer.
--            The default is to download enough data to launch a full graphical
--            installer, but a complete upgrade will be required if there is no
--            internet access during install time.
--        """
--        pklog.info("UpgradeSystem() was called")
--        GLib.idle_add(self._fail_not_implemented)
--
--    # pylint: disable-msg=C0103,C0322
--    @dbus_deferred_method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                          in_signature="t", out_signature="",
--                          sender_keyword="sender")
--    def RepairSystem(self, flags, sender):
--        """This method recovers the package managment system from e.g.
--        unsatisified dependencies of installed packages.
--
--        :param flags:
--            If the transaction is only allowed to install trusted packages.
--            Unsigned packages should not be installed if the flags
--            contains ONLY_TRUSED.
--            If this method is can only install trusted packages, and
--            the packages are unsigned, then the backend will send a
--            ErrorCode(missing-gpg-signature). On recieving this error, the
--            client may choose to retry with ONLY_TRUSTED set after
--            gaining further authentication.
--        """
--        pklog.info("RepairSystem() was called")
--        return self._repair_system(flags, sender)
--
--    @inline_callbacks
--    def _repair_system(self, flags, sender):
--        self.role = pk.RoleEnum.REPAIR_SYSTEM
--        self.flags = flags
--        self.trans = self._get_merged_trans(aptd_enums.ROLE_FIX_BROKEN_DEPENDS)
--        yield self.trans._set_property(
--            APTDAEMON_TRANSACTION_DBUS_INTERFACE,
--            "AllowUnauthenticated",
--            not bitfield_contains(flags,
--                                  pk.TransactionFlagEnum.ONLY_TRUSTED),
--            sender)
--        yield self.trans._run(sender)
--
--    # pylint: disable-msg=C0103,C0322
--    @dbus_deferred_method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                          in_signature="b", out_signature="",
--                          sender_keyword="sender")
--    def RefreshCache(self, force, sender):
--        """This method should fetch updated meta-data for all enabled
--        repositories.
--
--        When fetching each software source, ensure to emit RepoDetail for
--        the current source to give the user interface some extra details.
--        Be sure to have the "enabled" field set to true, otherwise you
--        wouldn't be fetching that source.
--
--        This method typically emits Progress, Error and RepoDetail.
--
--        :param force: If the caches should be cleaned and reloaded even if
--            there is valid, up to date data.
--        """
--        pklog.info("RefreshCache() was called")
--        self.role = pk.RoleEnum.REFRESH_CACHE
--        return self._refresh_cache(force, sender)
--
--    @inline_callbacks
--    def _refresh_cache(self, force, sender):
--        self.trans = self._get_merged_trans(aptd_enums.ROLE_UPDATE_CACHE,
--                                            kwargs={"sources_list": None})
--        yield self.trans._run(sender)
--
--    @dbus_deferred_method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                          in_signature="as", out_signature="",
--                          sender_keyword="sender")
--    def GetUpdateDetail(self, package_ids, sender):
--        """This method returns details about a specific update.
--
--        This method typically emits UpdateDetail and Error
--
--        :param package_ids: An array of package IDs.
--        """
--        pklog.info("GetUpdateDetail() was called")
--        self.role = pk.RoleEnum.GET_UPDATE_DETAIL
--        kwargs = {"package_ids": package_ids}
--        return self._run_query(kwargs, sender)
--
--    @dbus_deferred_method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                          in_signature="t", out_signature="",
--                          sender_keyword="sender")
--    def GetUpdates(self, filter, sender):
--        """This method should return a list of packages that are installed
--        and are upgradable. It should only return the newest update for
--        each installed package.
--
--        This method typically emits Progress, Error and Package.
--
--        :param filter: A correct filter, e.g. none or installed;~devel
--        """
--        pklog.info("GetUpdates() was called")
--        self.role = pk.RoleEnum.GET_UPDATES
--        kwargs = {"filters": filter}
--        return self._run_query(kwargs, sender)
--
--    @dbus.service.method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                         in_signature="", out_signature="",
--                         sender_keyword="sender")
--    def GetDistroUpgrades(self, sender):
--        """This method should return a list of distribution upgrades that are
--        available. It should not return updates, only major upgrades.
--
--        This method typically emits DistroUpgrade, Error
--        """
--        pklog.info("GetDistroUpgrades() was called")
--        self.role = pk.RoleEnum.GET_DISTRO_UPGRADES
--        self.status = pk.StatusEnum.RUNNING
--        GLib.idle_add(defer_idle, self._get_distro_upgrades)
--
--    def _get_distro_upgrades(self):
--        # FIXME: Should go into the worker after the threading branch is merged
--        #       It allows to run a nested loop until the download is finished
--        self.allow_cancel = False
--        self.percentage = 101
--        self.status = pk.StatusEnum.DOWNLOAD_UPDATEINFO
--
--        if META_RELEASE_SUPPORT is False:
--            self.ErrorCode(pk.ErrorEnum.INTERNAL_ERROR,
--                           "Please make sure that update-manager-core is"
--                           "correctly installed.")
--            self.exit = pk.ExitEnum.FAILED
--            return
--
--        # FIXME Evil to start the download during init
--        meta_release = GMetaRelease()
--        meta_release.connect("download-done",
--                             self._on_distro_upgrade_download_done)
--
--    def _on_distro_upgrade_download_done(self, meta_release):
--        # FIXME: Add support for description
--        if meta_release.new_dist is not None:
--            self.DistroUpgrade("stable",
--                               "%s %s" % (meta_release.new_dist.name,
--                                          meta_release.new_dist.version),
--                               "The latest stable release")
--        self.exit = pk.ExitEnum.SUCCESS
--
--    @dbus_deferred_method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                          in_signature="tas", out_signature="",
--                          sender_keyword="sender")
--    def Resolve(self, filter, packages, sender):
--        """This method turns a single package name into a package_id suitable
--        for the other methods.
--
--        If the package is a fully formed package_id, then this should be
--        treated as an exact package match. This is useful to find the summary
--        or installed status of a package_id returned from other methods.
--
--        This method typically emits Error and Package.
--
--        Package enumerated types should be available or installed.
--
--        :param filter: A correct filter, e.g. none or installed;~devel
--        :param packages:
--            An array of package names, e.g. scribus-clipart. The package
--            names are case sensitive, so for instance: Resolve('Packagekit')
--            would not match PackageKit. As a special case, if Resolve() is
--            called with a name prefixed with @ then this should be treated as
--            a category, for example: @web-development. In this instance, a
--            meta-package should be emitted, for example:
--            web-development;;;meta with the correct installed status and
--            summary for the category.
--        """
--        pklog.info("Resolve() was called: %s", get_string_from_array(packages))
--        self.role = pk.RoleEnum.RESOLVE
--        kwargs = {"filters": filter, "packages": packages}
--        return self._run_query(kwargs, sender)
--
--    @dbus_deferred_method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                          in_signature="t", out_signature="",
--                          sender_keyword="sender")
--    def GetPackages(self, filter, sender):
--        """This method returns all the packages without a search term.
--
--        This method typically emits Progress, Error and Package.
--
--        Package enumerated types should be available or installed.
--
--        :param filter: A correct filter, e.g. none or installed;~devel
--        """
--        pklog.info("GetPackages() was called")
--        self.role = pk.RoleEnum.GET_PACKAGES
--        kwargs = {"filters": filter}
--        return self._run_query(kwargs, sender)
--
--    @dbus_deferred_method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                          in_signature="as", out_signature="",
--                          sender_keyword="sender")
--    def GetDetails(self, package_ids, sender):
--        """This method should return all the details about a specific
--        package_id.
--
--        This method typically emits Progress, Status and Error and Details.
--
--        :param package_ids: An array of package IDs.
--        """
--        pklog.info("GetDetails() was called")
--        self.role = pk.RoleEnum.GET_DETAILS
--        kwargs = {"package_ids": package_ids}
--        return self._run_query(kwargs, sender)
--
--    @dbus_deferred_method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                          in_signature="as", out_signature="",
--                          sender_keyword="sender")
--    def GetFiles(self, package_ids, sender):
--        """This method should return the file list of the package_id.
--
--        This method typically emits Progress, Status and Error and Files.
--
--        :param package_ids: An array of package IDs.
--        """
--        pklog.info("GetFiles() was called")
--        self.role = pk.RoleEnum.GET_FILES
--        kwargs = {"package_ids": package_ids}
--        return self._run_query(kwargs, sender)
--
--    @dbus_deferred_method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                          in_signature="tas", out_signature="",
--                          sender_keyword="sender")
--    def SearchFiles(self, filter, values, sender):
--        """This method searches for files on the local system and files in
--        available packages.
--
--        This should search for files. This should allow an application to
--        find out what package owns a file on the system.
--
--        This method typically emits Progress, Error and Package.
--
--        Package enumerated types should be available or installed.
--
--        :param filter: A correct filter, e.g. none or installed;~devel
--        :param values:
--            A filename or fully qualified path and filename on the system.
--            If the search term begins with a / it will be assumed the entire
--            path has been given and only packages that contain this exact
--            path and filename will be returned. If the search term does not
--            start with / then it should be treated as a single filename,
--            which can be in any directory. The search is case sensitive,
--            and should not be escaped or surrounded in quotes.
--        """
--        pklog.info("SearchFiles() was called")
--        self.role = pk.RoleEnum.SEARCH_FILE
--        kwargs = {"filters": filter,
--                  "values": values}
--        return self._run_query(kwargs, sender)
--
--    @dbus_deferred_method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                          in_signature="tas", out_signature="",
--                          sender_keyword="sender")
--    def SearchDetails(self, filter, values, sender):
--        """This method allows deeper searching than SearchName().
--
--        Do not refresh the package cache. This should be fast. This is very
--        similar to search-name. This should search as much data as possible,
--        including, if possible repo names, package summaries, descriptions,
--        licenses and URLs.
--
--        Try to emit installed before available packages first, as it allows
--        the client program to perform the GUI filtering and matching whilst
--        the daemon is running the transaction.
--
--        If the backend includes installed and available versions of the same
--        package when searching then the available version will have to be
--        filtered in the backend.
--
--        This method typically emits Progress, Error and Package.
--
--        Package enumerated types should be available or installed.
--
--        :param filter: A correct filter, e.g. none or installed;~devel
--        :param values:
--            A single word search term with no wildcard chars. The search term
--            can contain many words separated by spaces. In this case, the
--            search operator is AND. For example, search of gnome power should
--            returns gnome-power-manager but not gnomesword or powertop.
--            The search should not be treated as case sensitive.
--        """
--        pklog.info("SearchDetails() was called")
--        self.role = pk.RoleEnum.SEARCH_DETAILS
--        kwargs = {"filters": filter,
--                  "values": values}
--        return self._run_query(kwargs, sender)
--
--    @dbus_deferred_method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                          in_signature="tas", out_signature="",
--                          sender_keyword="sender")
--    def SearchGroups(self, filter, values, sender):
--        """This method returns packages from a given group enumerated type.
--
--        Do not refresh the package cache. This should be fast.
--
--        Try to emit installed before available packages first, as it
--        allows the client program to perform the GUI filtering and matching
--        whilst the daemon is running the transaction.
--
--        If the backend includes installed and available versions of the same
--        package when searching then the available version will have to be
--        filtered in the backend.
--
--        This method typically emits Progress, Error and Package.
--
--        Package enumerated types should be available or installed.
--
--        :param filter: A correct filter, e.g. none or installed;~devel
--        :param values:
--            An enumerated group type, or unknown. The search cannot contain
--            spaces. The following recommendations are made below: If the values
--            strings are prefixed with category: then the request is treated
--            as a 'category search', for example: category:web-development.
--            repo: then the request is treated as a 'repository search', for
--            example: repo:fedora-debuginfo. In this instance all packages that
--            were either installed from, or can be installed from the
--            fedora-debuginfo source would be returned.
--        """
--        pklog.info("SearchGroups() was called")
--        self.role = pk.RoleEnum.SEARCH_GROUP
--        kwargs = {"filters": filter,
--                  "values": values}
--        return self._run_query(kwargs, sender)
--
--    @dbus_deferred_method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                          in_signature="tas", out_signature="",
--                          sender_keyword="sender")
--    def SearchNames(self, filter, values, sender):
--        """This method searches the package database by package name.
--
--        Try to emit installed before available packages first, as it
--        allows the client program to perform the GUI filtering and matching
--        whilst the daemon is running the transaction.
--
--        If the backend includes installed and available versions of the same
--        package when searching then the available version will have to be
--        filtered in the backend.
--
--        The search methods should return all results in all repositories.
--        This may mean that multiple versions of package are returned. If this
--        is not what is wanted by the client program, then the newest filter
--        should be used.
--
--        This method typically emits Progress, Error and Package.
--
--        Package enumerated types should be available or installed.
--
--        :param filter: A correct filter, e.g. none or installed;~devel
--        :param values:
--            A single word search term with no wildcard chars. The search term
--            can contain many words separated by spaces. In this case, the
--            search operator is AND. For example, search of gnome power should
--            returns gnome-power-manager but not gnomesword or powertop.
--            The search should not be treated as case sensitive.
--        """
--        pklog.info("SearchNames() was called")
--        self.role = pk.RoleEnum.SEARCH_NAME
--        kwargs = {"filters": filter,
--                  "values": values}
--        return self._run_query(kwargs, sender)
--
--    @dbus.service.method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                         in_signature="s", out_signature="",
--                         sender_keyword="sender")
--    def AcceptEula(self, eula_id, sender):
--        """This method allows the user to accept a end user licence agreement.
--
--        :param eula_id: A valid EULA ID
--        """
--        self.role = pk.RoleEnum.ACCEPT_EULA
--        GLib.idle_add(self._fail_not_implemented)
--
--    @dbus_deferred_method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                          in_signature="bas", out_signature="",
--                          sender_keyword="sender")
--    def DownloadPackages(self, store_in_cache, package_ids, sender):
--        """This method downloads packages into a temporary directory.
--
--        This method should emit one Files signal for each package that
--        is downloaded, with the file list set as the name of the complete
--        downloaded file and directory, so for example:
--
--        DownloadPackages('hal;0.1.2;i386;fedora',
--        'hal-info;2009-09-07;no-arch;updates') should send two signals,
--        e.g. Files('hal;0.1.2;i386;fedora', '/tmp/hal-0.1.2.i386.rpm')
--        and Files('hal-info;2009-09-07;no-arch;updates',
--        '/tmp/hal-info-2009-09-07.noarch.rpm').
--
--        :param store_in_cache:
--            If the downloaded files should be stored in the system package
--            cache rather than copied into a newly created directory. See the
--            developer docs for more details on how this is supposed to work.
--        :param package_ids: An array of package IDs.
--        """
--        pklog.info("DownloadPackages() was called: %s",
--                   get_string_from_array(package_ids))
--        self.role = pk.RoleEnum.DOWNLOAD_PACKAGES
--        kwargs = {"store_in_cache": store_in_cache,
--                  "package_ids": package_ids}
--        return self._run_query(kwargs, sender)
--
--    @dbus.service.method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                         in_signature="u", out_signature="",
--                         sender_keyword="sender")
--    def GetOldTransactions(self, number, sender):
--        """This method allows a client to view details for old transactions.
--
--        :param number:
--            The number of past transactions, or 0 for all known transactions.
--        """
--        pklog.info("GetOldTransactions() was called: %s", str(number))
--        self.role = pk.RoleEnum.GET_OLD_TRANSACTIONS
--        GLib.idle_add(self._fail_not_implemented)
--
--    @dbus.service.method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                         in_signature="t", out_signature="",
--                         sender_keyword="sender")
--    def GetRepoList(self, filter, sender):
--        """This method returns the list of repositories used in the system.
--
--        This method should emit RepoDetail.
--
--        :param filter: A correct filter, e.g. none or installed;~devel
--        """
--        pklog.info("GetRepoList() was called")
--        self.role = pk.RoleEnum.GET_REPO_LIST
--        GLib.idle_add(self._fail_not_implemented)
--
--    @dbus_deferred_method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                          in_signature="tas", out_signature="",
--                          sender_keyword="sender")
--    def InstallFiles(self, flags, full_paths, sender):
--        """This method installs local package files onto the local system.
--
--        The installer should always install extra dependant packages
--        automatically.
--
--        This method typically emits Progress, Status and Error and Package.
--
--        Package enumerated types should be downloading, updating, installing
--        or removing.
--
--        :param flags:
--            If the transaction is only allowed to install trusted packages.
--            Unsigned packages should not be installed if the flags
--            contains ONLY_TRUSED.
--            If this method is can only install trusted packages, and
--            the packages are unsigned, then the backend will send a
--            ErrorCode(missing-gpg-signature). On recieving this error, the
--            client may choose to retry with ONLY_TRUSTED set after
--            gaining further authentication.
--        :param full_paths: An array of full path and filenames to packages.
--        """
--        pklog.info("InstallFiles() was called: %s, %s",
--                   get_string_from_flags(flags),
--                   get_string_from_array(full_paths))
--        return self._install_files(flags, full_paths, sender)
--
--    @inline_callbacks
--    def _install_files(self, flags, full_paths, sender):
--        self.role = pk.RoleEnum.INSTALL_FILES
--        self.flags = flags
--        # Python-APT only supports installing one file
--        if len(full_paths) != 1:
--            self.ErrorCode(pk.ErrorEnum.NOT_SUPPORTED,
--                           "Only one package can be "
--                           "installed at the same time.")
--            self.exit = pk.ExitEnum.FAILED
--            raise StopIteration
--        path = full_paths[0]
--        if not os.path.abspath(path):
--            self.ErrorCode(pk.ErrorEnum.NOT_SUPPORTED,
--                           "Path is not absolute: %s")
--            self.exit = pk.ExitEnum.FAILED
--            raise StopIteration
--        if not os.path.isfile(path):
--            self.ErrorCode(pk.ErrorEnum.INVALID_PACKAGE_FILE,
--                           "File doesn't exist: %s" % path)
--            self.exit = pk.ExitEnum.FAILED
--            raise StopIteration
--
--        kwargs = {"path": path,
--                  "force": True}
--        self.trans = self._get_merged_trans(aptd_enums.ROLE_INSTALL_FILE,
--                                            kwargs=kwargs)
--        yield self.trans._run(sender)
--
--    @dbus_deferred_method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                          in_signature="uss", out_signature="",
--                          sender_keyword="sender")
--    def InstallSignature(self, sig_type, key_id, package_id, sender):
--        """This method allows us to install new security keys.
--
--        :param sig_type: A key type, e.g. gpg
--        :param key_id: A key ID, e.g. BB7576AC
--        :param package_id:
--            A PackageID for the package that the user is trying to install
--            (ignored)
--        """
--        pklog.info("InstallSignature() was called: %s", str(key_id))
--        self.role = pk.RoleEnum.INSTALL_SIGNATURE
--        kwargs = {"sig_type": sig_type,
--                  "key_id": key_id,
--                  "package_id": package_id}
--        return self._run_query(kwargs, sender)
--
--    @dbus.service.method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                         in_signature="sss", out_signature="",
--                         sender_keyword="sender")
--    def RepoSetData(self, repo_id, parameter, value, sender):
--        """This method allows arbitary data to be passed to the repository
--        handler.
--
--        :param repo_id:
--            A repository identifier, e.g. fedora-development-debuginfo
--        :param parameter:
--            The backend specific value, e.g. set-download-url.
--        :param value:
--            The backend specific value, e.g. http://foo.bar.org/baz.
--        """
--        pklog.info("RepoSetData() was called: %s, %s, %s",
--                   str(repo_id), str(parameter), str(value))
--        self.role = pk.RoleEnum.REPO_SET_DATA
--        GLib.idle_add(self._fail_not_implemented)
--
--    @dbus_deferred_method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                          in_signature="sb", out_signature="",
--                          sender_keyword="sender")
--    def RepoEnable(self, repo_id, enabled, sender):
--        """This method enables the repository specified.
--
--        :param repo_id:
--            A repository identifier, e.g. fedora-development-debuginfo or an
--            apt source ("deb http://... unstable main")
--        :param enabled: true if enabled, false if disabled.
--        """
--        pklog.info("RepoEnable() was called(): %s, %s",
--                   str(repo_id), str(enabled))
--        self.role = pk.RoleEnum.REPO_ENABLE
--        kwargs = {"repo_id": repo_id,
--                  "enabled": enabled}
--        return self._run_query(kwargs, sender)
--
--    @dbus_deferred_method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                          in_signature="tsas", out_signature="",
--                          sender_keyword="sender")
--    def WhatProvides(self, filter, type, values, sender):
--        """This method returns packages that provide the supplied attributes.
--        This method is useful for finding out what package(s) provide a
--        modalias or GStreamer codec string.
--
--        This method typically emits Progress, Status and Error and Package.
--
--        Package enumerated types should be available or installed.
--
--        :param filter:
--            A correct filter, e.g. none or installed;~devel
--        :param type:
--            A PkProvideType, e.g. PK_PROVIDES_ENUM_CODEC.
--        :param values:
--            The data to send to the backend to get the packages. Note: This
--            is backend specific.
--        """
--        pklog.info("WhatProvides() was called")
--        self.role = pk.RoleEnum.WHAT_PROVIDES
--        kwargs = {"filters": filter,
--                  "provides_type": type,
--                  "values": values}
--        return self._run_query(kwargs, sender)
--
--    @dbus.service.method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                         in_signature="", out_signature="",
--                         sender_keyword="sender")
--    def GetCategories(self, sender):
--        pklog.info("GetCategories() was called")
--        """This method return the collection categories"""
--        self.role = pk.RoleEnum.GET_CATEGORIES
--        GLib.idle_add(self._fail_not_implemented)
--
--    @dbus_deferred_method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                          in_signature="tasb", out_signature="",
--                          sender_keyword="sender")
--    def GetRequires(self, filter, package_ids, recursive, sender):
--        """This method returns packages that depend on this package. This is
--        useful to know, as if package_id is being removed, we can warn the
--        user what else would be removed.
--
--        This method typically emits Progress, Status and Error and Package.
--
--        Package enumerated types should be available or installed.
--
--        :param filter: A correct filter, e.g. none or installed;~devel
--        :param package_ids: An array of package IDs.
--        :param recursive:
--            Either true or false. If yes then the requirements should be
--            returned for all packages returned. This means if
--            gnome-power-manager depends on NetworkManager and NetworkManager
--            depends on HAL, then GetRequires on HAL should return both
--            gnome-power-manager and NetworkManager.
--        """
--        pklog.info("GetRequires() was called")
--        self.role = pk.RoleEnum.GET_REQUIRES
--        kwargs = {"filters": filter,
--                  "package_ids": package_ids,
--                  "recursive": recursive}
--        return self._run_query(kwargs, sender)
--
--    @dbus_deferred_method(PACKAGEKIT_TRANS_DBUS_INTERFACE,
--                          in_signature="tasb", out_signature="",
--                          sender_keyword="sender")
--    def GetDepends(self, filter, package_ids, recursive, sender):
--        """This method returns packages that this package depends on.
--
--        This method typically emits Progress, Status and Error and Package.
--
--        Package enumerated types should be available or installed.
--
--        :param filter: A correct filter, e.g. none or installed;~devel
--        :param package_ids: An array of package IDs.
--        :param recursive:
--            Either true or false. If yes then the requirements should be
--            returned for all packages returned. This means if
--            gnome-power-manager depends on NetworkManager and NetworkManager
--            depends on HAL, then GetDepends on gnome-power-manager should
--            return both HAL and NetworkManager.
--        """
--        pklog.info("GetDepends() was called")
--        self.role = pk.RoleEnum.GET_DEPENDS
--        kwargs = {"filters": filter,
--                  "package_ids": package_ids,
--                  "recursive": recursive}
--        return self._run_query(kwargs, sender)
--
--    # HELPERS
--
--    def _fail_not_implemented(self):
--        self.ErrorCode(pk.ErrorEnum.NOT_SUPPORTED, "Unimplemented method")
--        self.exit = pk.ExitEnum.FAILED
--        return False
--
--    def _get_properties(self, iface):
--        """Helper to get the properties of a D-Bus interface."""
--        if iface == PACKAGEKIT_TRANS_DBUS_INTERFACE:
--            return {"Role": dbus.UInt32(self.role),
--                    "Status": dbus.UInt32(self.status),
--                    "LastPackage": dbus.String(self.last_package),
--                    "Uid": dbus.UInt32(self.uid),
--                    "Percentage": dbus.UInt32(self.percentage),
--                    "AllowCancel": dbus.Boolean(self.allow_cancel),
--                    "CallerActive": dbus.Boolean(self.caller_active),
--                    "ElapsedTime": dbus.UInt32(self.elapsed_time),
--                    "RemainingTime": dbus.UInt32(self.remaining_time),
--                    "DownloadSizeRemaining": dbus.UInt64(
--                        self.download_size_remaining),
--                    "TransactionFlags": dbus.UInt64(self.flags),
--                    "Speed": dbus.UInt32(self.speed)
--                    }
--        else:
--            return {}
--
--    @inline_callbacks
--    def _run_query(self, kwargs, sender):
--        self.trans = self._get_merged_trans(aptd_enums.ROLE_PK_QUERY,
--                                            kwargs=kwargs)
--        yield self.trans._run(sender)
--
--    def _get_aptd_package_id(self, pk_id):
--        """Convert a PackageKit Package ID to the apt syntax.
--        e.g. xterm;235;i386;installed to xterm:i386=235
--        """
--        name, version, arch, data = pk_id.split(";")
--        id = name
--        if arch != self.queue.worker.NATIVE_ARCH and arch != "all":
--            id += ":%s" % arch
--        if version:
--            id += "=%s" % version
--        return id
--
--    def _get_merged_trans(self, role, pkg_ids=None, pkg_type=None,
--                          kwargs=None):
--        if pkg_ids:
--            packages = [[], [], [], [], [], []]
--            packages[pkg_type] = [self._get_aptd_package_id(pkg)
--                                  for pkg in pkg_ids]
--        else:
--            packages = None
--        if self.trans:
--            raise Exception("%s: Transaction may only run once." %
--                            pk.ErrorEnum.TRANSACTION_FAILED)
--        trans = MergedTransaction(self, role, self.queue,
--                                  packages=packages, kwargs=kwargs)
--        try:
--            trans._set_locale(self.hints["locale"])
--        except (KeyError, ValueError):
--            # If the locale isn't vaild or supported a ValueError
--            # will be raised
--            pass
--        try:
--            trans._set_debconf(self.hints["frontend-socket"])
--        except KeyError:
--            pass
--        self.queue.limbo[trans.tid] = trans
--        return trans
--
--
--if META_RELEASE_SUPPORT:
--
--    class GMetaRelease(GObject.GObject, MetaReleaseCore):
--
--        __gsignals__ = {"download-done": (GObject.SignalFlags.RUN_FIRST,
--                                          None,
--                                          ())}
--
--        def __init__(self):
--            GObject.GObject.__init__(self)
--            MetaReleaseCore.__init__(self, False, False)
--
--        def download(self):
--            MetaReleaseCore.download(self)
--            self.emit("download-done")
--
--
--def get_pk_exit_enum(enum):
--    try:
--        return MAP_EXIT_ENUM[enum]
--    except KeyError:
--        return pk.ExitEnum.UNKNOWN
--
--
--def get_pk_status_enum(enum):
--    try:
--        return MAP_STATUS_ENUM[enum]
--    except KeyError:
--        return pk.StatusEnum.UNKNOWN
--
--
--def get_pk_package_enum(enum):
--    try:
--        return MAP_PACKAGE_ENUM[enum]
--    except KeyError:
--        return pk.InfoEnum.UNKNOWN
--
--
--def get_pk_error_enum(enum):
--    try:
--        return MAP_ERROR_ENUM[enum]
--    except KeyError:
--        return pk.ErrorEnum.UNKNOWN
--
--
--def get_pk_package_id(pk_id, data=""):
--    """Convert an AptDaemon package ID to the PackageKit syntax.
--    e.g. xterm:i368=235; to xterm;235;i386;installed
--    """
--    # FIXME add arch support
--    name, version, release = split_package_id(pk_id)
--    try:
--        name, arch = name.split(":", 1)
--    except ValueError:
--        arch = ""
--    if version is None:
--        version = ""
--    if release is None:
--        release = ""
--    return "%s;%s;%s;%s" % (name, version, arch, data or release)
--
--
--def defer_idle(func, *args):
--    func(*args)
--    return False
--
--
--def get_string_from_flags(flags):
--    """Return a human readable string of the applied transaction flags."""
--    ret = ""
--    if flags == pk.TransactionFlagEnum.NONE:
--        return "simulate"
--    if bitfield_contains(flags, pk.TransactionFlagEnum.SIMULATE):
--        ret += " simulate"
--    if bitfield_contains(flags, pk.TransactionFlagEnum.ONLY_DOWNLOAD):
--        ret += " only-download"
--    if bitfield_contains(flags, pk.TransactionFlagEnum.ONLY_TRUSTED):
--        ret += " only-trusted"
--    return ret.strip()
--
--
--def get_string_from_array(array):
--    """Convert a DBus Array to a human readable format"""
--    return [str(value) for value in array]
--
--
--# vim: ts=4 et sts=4