xNightR00T File Manager

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.10
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.





from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_solv')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_solv')
    _solv = swig_import_helper()
    del swig_import_helper
elif _swig_python_version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_solv', [dirname(__file__)])
        except ImportError:
            import _solv
            return _solv
        if fp is not None:
            try:
                _mod = imp.load_module('_solv', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _solv = swig_import_helper()
    del swig_import_helper
else:
    import _solv
del _swig_python_version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr(self, class_type, name):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except __builtin__.Exception:
    class _object:
        pass
    _newclass = 0

ID_NULL = _solv.ID_NULL
ID_EMPTY = _solv.ID_EMPTY
SOLVABLE_NAME = _solv.SOLVABLE_NAME
SOLVABLE_ARCH = _solv.SOLVABLE_ARCH
SOLVABLE_EVR = _solv.SOLVABLE_EVR
SOLVABLE_VENDOR = _solv.SOLVABLE_VENDOR
SOLVABLE_PROVIDES = _solv.SOLVABLE_PROVIDES
SOLVABLE_OBSOLETES = _solv.SOLVABLE_OBSOLETES
SOLVABLE_CONFLICTS = _solv.SOLVABLE_CONFLICTS
SOLVABLE_REQUIRES = _solv.SOLVABLE_REQUIRES
SOLVABLE_RECOMMENDS = _solv.SOLVABLE_RECOMMENDS
SOLVABLE_SUGGESTS = _solv.SOLVABLE_SUGGESTS
SOLVABLE_SUPPLEMENTS = _solv.SOLVABLE_SUPPLEMENTS
SOLVABLE_ENHANCES = _solv.SOLVABLE_ENHANCES
RPM_RPMDBID = _solv.RPM_RPMDBID
SOLVABLE_PREREQMARKER = _solv.SOLVABLE_PREREQMARKER
SOLVABLE_FILEMARKER = _solv.SOLVABLE_FILEMARKER
NAMESPACE_INSTALLED = _solv.NAMESPACE_INSTALLED
NAMESPACE_MODALIAS = _solv.NAMESPACE_MODALIAS
NAMESPACE_SPLITPROVIDES = _solv.NAMESPACE_SPLITPROVIDES
NAMESPACE_LANGUAGE = _solv.NAMESPACE_LANGUAGE
NAMESPACE_FILESYSTEM = _solv.NAMESPACE_FILESYSTEM
NAMESPACE_OTHERPROVIDERS = _solv.NAMESPACE_OTHERPROVIDERS
SYSTEM_SYSTEM = _solv.SYSTEM_SYSTEM
ARCH_SRC = _solv.ARCH_SRC
ARCH_NOSRC = _solv.ARCH_NOSRC
ARCH_NOARCH = _solv.ARCH_NOARCH
ARCH_ALL = _solv.ARCH_ALL
ARCH_ANY = _solv.ARCH_ANY
REPOSITORY_SOLVABLES = _solv.REPOSITORY_SOLVABLES
REPOSITORY_DELTAINFO = _solv.REPOSITORY_DELTAINFO
REPOSITORY_EXTERNAL = _solv.REPOSITORY_EXTERNAL
REPOSITORY_KEYS = _solv.REPOSITORY_KEYS
REPOSITORY_LOCATION = _solv.REPOSITORY_LOCATION
REPOSITORY_ADDEDFILEPROVIDES = _solv.REPOSITORY_ADDEDFILEPROVIDES
REPOSITORY_RPMDBCOOKIE = _solv.REPOSITORY_RPMDBCOOKIE
REPOKEY_TYPE_VOID = _solv.REPOKEY_TYPE_VOID
REPOKEY_TYPE_CONSTANT = _solv.REPOKEY_TYPE_CONSTANT
REPOKEY_TYPE_CONSTANTID = _solv.REPOKEY_TYPE_CONSTANTID
REPOKEY_TYPE_ID = _solv.REPOKEY_TYPE_ID
REPOKEY_TYPE_NUM = _solv.REPOKEY_TYPE_NUM
REPOKEY_TYPE_U32 = _solv.REPOKEY_TYPE_U32
REPOKEY_TYPE_DIR = _solv.REPOKEY_TYPE_DIR
REPOKEY_TYPE_STR = _solv.REPOKEY_TYPE_STR
REPOKEY_TYPE_BINARY = _solv.REPOKEY_TYPE_BINARY
REPOKEY_TYPE_IDARRAY = _solv.REPOKEY_TYPE_IDARRAY
REPOKEY_TYPE_REL_IDARRAY = _solv.REPOKEY_TYPE_REL_IDARRAY
REPOKEY_TYPE_DIRSTRARRAY = _solv.REPOKEY_TYPE_DIRSTRARRAY
REPOKEY_TYPE_DIRNUMNUMARRAY = _solv.REPOKEY_TYPE_DIRNUMNUMARRAY
REPOKEY_TYPE_MD5 = _solv.REPOKEY_TYPE_MD5
REPOKEY_TYPE_SHA1 = _solv.REPOKEY_TYPE_SHA1
REPOKEY_TYPE_SHA224 = _solv.REPOKEY_TYPE_SHA224
REPOKEY_TYPE_SHA256 = _solv.REPOKEY_TYPE_SHA256
REPOKEY_TYPE_SHA384 = _solv.REPOKEY_TYPE_SHA384
REPOKEY_TYPE_SHA512 = _solv.REPOKEY_TYPE_SHA512
REPOKEY_TYPE_FIXARRAY = _solv.REPOKEY_TYPE_FIXARRAY
REPOKEY_TYPE_FLEXARRAY = _solv.REPOKEY_TYPE_FLEXARRAY
REPOKEY_TYPE_DELETED = _solv.REPOKEY_TYPE_DELETED
SOLVABLE_SUMMARY = _solv.SOLVABLE_SUMMARY
SOLVABLE_DESCRIPTION = _solv.SOLVABLE_DESCRIPTION
SOLVABLE_DISTRIBUTION = _solv.SOLVABLE_DISTRIBUTION
SOLVABLE_AUTHORS = _solv.SOLVABLE_AUTHORS
SOLVABLE_PACKAGER = _solv.SOLVABLE_PACKAGER
SOLVABLE_GROUP = _solv.SOLVABLE_GROUP
SOLVABLE_URL = _solv.SOLVABLE_URL
SOLVABLE_KEYWORDS = _solv.SOLVABLE_KEYWORDS
SOLVABLE_LICENSE = _solv.SOLVABLE_LICENSE
SOLVABLE_BUILDTIME = _solv.SOLVABLE_BUILDTIME
SOLVABLE_BUILDHOST = _solv.SOLVABLE_BUILDHOST
SOLVABLE_EULA = _solv.SOLVABLE_EULA
SOLVABLE_CPEID = _solv.SOLVABLE_CPEID
SOLVABLE_MESSAGEINS = _solv.SOLVABLE_MESSAGEINS
SOLVABLE_MESSAGEDEL = _solv.SOLVABLE_MESSAGEDEL
SOLVABLE_INSTALLSIZE = _solv.SOLVABLE_INSTALLSIZE
SOLVABLE_DISKUSAGE = _solv.SOLVABLE_DISKUSAGE
SOLVABLE_FILELIST = _solv.SOLVABLE_FILELIST
SOLVABLE_INSTALLTIME = _solv.SOLVABLE_INSTALLTIME
SOLVABLE_MEDIADIR = _solv.SOLVABLE_MEDIADIR
SOLVABLE_MEDIAFILE = _solv.SOLVABLE_MEDIAFILE
SOLVABLE_MEDIANR = _solv.SOLVABLE_MEDIANR
SOLVABLE_MEDIABASE = _solv.SOLVABLE_MEDIABASE
SOLVABLE_DOWNLOADSIZE = _solv.SOLVABLE_DOWNLOADSIZE
SOLVABLE_SOURCEARCH = _solv.SOLVABLE_SOURCEARCH
SOLVABLE_SOURCENAME = _solv.SOLVABLE_SOURCENAME
SOLVABLE_SOURCEEVR = _solv.SOLVABLE_SOURCEEVR
SOLVABLE_ISVISIBLE = _solv.SOLVABLE_ISVISIBLE
SOLVABLE_TRIGGERS = _solv.SOLVABLE_TRIGGERS
SOLVABLE_CHECKSUM = _solv.SOLVABLE_CHECKSUM
SOLVABLE_PKGID = _solv.SOLVABLE_PKGID
SOLVABLE_HDRID = _solv.SOLVABLE_HDRID
SOLVABLE_LEADSIGID = _solv.SOLVABLE_LEADSIGID
SOLVABLE_PATCHCATEGORY = _solv.SOLVABLE_PATCHCATEGORY
SOLVABLE_HEADEREND = _solv.SOLVABLE_HEADEREND
SOLVABLE_CHANGELOG = _solv.SOLVABLE_CHANGELOG
SOLVABLE_CHANGELOG_AUTHOR = _solv.SOLVABLE_CHANGELOG_AUTHOR
SOLVABLE_CHANGELOG_TIME = _solv.SOLVABLE_CHANGELOG_TIME
SOLVABLE_CHANGELOG_TEXT = _solv.SOLVABLE_CHANGELOG_TEXT
SOLVABLE_CATEGORY = _solv.SOLVABLE_CATEGORY
SOLVABLE_INCLUDES = _solv.SOLVABLE_INCLUDES
SOLVABLE_EXTENDS = _solv.SOLVABLE_EXTENDS
SOLVABLE_ICON = _solv.SOLVABLE_ICON
SOLVABLE_ORDER = _solv.SOLVABLE_ORDER
UPDATE_REBOOT = _solv.UPDATE_REBOOT
UPDATE_RESTART = _solv.UPDATE_RESTART
UPDATE_RELOGIN = _solv.UPDATE_RELOGIN
UPDATE_MESSAGE = _solv.UPDATE_MESSAGE
UPDATE_SEVERITY = _solv.UPDATE_SEVERITY
UPDATE_RIGHTS = _solv.UPDATE_RIGHTS
UPDATE_COLLECTION = _solv.UPDATE_COLLECTION
UPDATE_COLLECTION_NAME = _solv.UPDATE_COLLECTION_NAME
UPDATE_COLLECTION_EVR = _solv.UPDATE_COLLECTION_EVR
UPDATE_COLLECTION_ARCH = _solv.UPDATE_COLLECTION_ARCH
UPDATE_COLLECTION_FILENAME = _solv.UPDATE_COLLECTION_FILENAME
UPDATE_COLLECTION_FLAGS = _solv.UPDATE_COLLECTION_FLAGS
UPDATE_REFERENCE = _solv.UPDATE_REFERENCE
UPDATE_REFERENCE_TYPE = _solv.UPDATE_REFERENCE_TYPE
UPDATE_REFERENCE_HREF = _solv.UPDATE_REFERENCE_HREF
UPDATE_REFERENCE_ID = _solv.UPDATE_REFERENCE_ID
UPDATE_REFERENCE_TITLE = _solv.UPDATE_REFERENCE_TITLE
PRODUCT_REFERENCEFILE = _solv.PRODUCT_REFERENCEFILE
PRODUCT_SHORTLABEL = _solv.PRODUCT_SHORTLABEL
PRODUCT_DISTPRODUCT = _solv.PRODUCT_DISTPRODUCT
PRODUCT_DISTVERSION = _solv.PRODUCT_DISTVERSION
PRODUCT_TYPE = _solv.PRODUCT_TYPE
PRODUCT_URL = _solv.PRODUCT_URL
PRODUCT_URL_TYPE = _solv.PRODUCT_URL_TYPE
PRODUCT_FLAGS = _solv.PRODUCT_FLAGS
PRODUCT_PRODUCTLINE = _solv.PRODUCT_PRODUCTLINE
PRODUCT_REGISTER_TARGET = _solv.PRODUCT_REGISTER_TARGET
PRODUCT_REGISTER_RELEASE = _solv.PRODUCT_REGISTER_RELEASE
PRODUCT_UPDATES_REPOID = _solv.PRODUCT_UPDATES_REPOID
PRODUCT_UPDATES = _solv.PRODUCT_UPDATES
PRODUCT_ENDOFLIFE = _solv.PRODUCT_ENDOFLIFE
SUSETAGS_DATADIR = _solv.SUSETAGS_DATADIR
SUSETAGS_DESCRDIR = _solv.SUSETAGS_DESCRDIR
SUSETAGS_DEFAULTVENDOR = _solv.SUSETAGS_DEFAULTVENDOR
SUSETAGS_FILE = _solv.SUSETAGS_FILE
SUSETAGS_FILE_NAME = _solv.SUSETAGS_FILE_NAME
SUSETAGS_FILE_TYPE = _solv.SUSETAGS_FILE_TYPE
SUSETAGS_FILE_CHECKSUM = _solv.SUSETAGS_FILE_CHECKSUM
SUSETAGS_SHARE_NAME = _solv.SUSETAGS_SHARE_NAME
SUSETAGS_SHARE_EVR = _solv.SUSETAGS_SHARE_EVR
SUSETAGS_SHARE_ARCH = _solv.SUSETAGS_SHARE_ARCH
REPOSITORY_TIMESTAMP = _solv.REPOSITORY_TIMESTAMP
REPOSITORY_EXPIRE = _solv.REPOSITORY_EXPIRE
REPOSITORY_UPDATES = _solv.REPOSITORY_UPDATES
REPOSITORY_DISTROS = _solv.REPOSITORY_DISTROS
REPOSITORY_PRODUCT_LABEL = _solv.REPOSITORY_PRODUCT_LABEL
REPOSITORY_PRODUCT_CPEID = _solv.REPOSITORY_PRODUCT_CPEID
REPOSITORY_REPOID = _solv.REPOSITORY_REPOID
REPOSITORY_KEYWORDS = _solv.REPOSITORY_KEYWORDS
REPOSITORY_REVISION = _solv.REPOSITORY_REVISION
REPOSITORY_TOOLVERSION = _solv.REPOSITORY_TOOLVERSION
DELTA_PACKAGE_NAME = _solv.DELTA_PACKAGE_NAME
DELTA_PACKAGE_EVR = _solv.DELTA_PACKAGE_EVR
DELTA_PACKAGE_ARCH = _solv.DELTA_PACKAGE_ARCH
DELTA_LOCATION_DIR = _solv.DELTA_LOCATION_DIR
DELTA_LOCATION_NAME = _solv.DELTA_LOCATION_NAME
DELTA_LOCATION_EVR = _solv.DELTA_LOCATION_EVR
DELTA_LOCATION_SUFFIX = _solv.DELTA_LOCATION_SUFFIX
DELTA_DOWNLOADSIZE = _solv.DELTA_DOWNLOADSIZE
DELTA_CHECKSUM = _solv.DELTA_CHECKSUM
DELTA_BASE_EVR = _solv.DELTA_BASE_EVR
DELTA_SEQ_NAME = _solv.DELTA_SEQ_NAME
DELTA_SEQ_EVR = _solv.DELTA_SEQ_EVR
DELTA_SEQ_NUM = _solv.DELTA_SEQ_NUM
DELTA_LOCATION_BASE = _solv.DELTA_LOCATION_BASE
REPOSITORY_REPOMD = _solv.REPOSITORY_REPOMD
REPOSITORY_REPOMD_TYPE = _solv.REPOSITORY_REPOMD_TYPE
REPOSITORY_REPOMD_LOCATION = _solv.REPOSITORY_REPOMD_LOCATION
REPOSITORY_REPOMD_TIMESTAMP = _solv.REPOSITORY_REPOMD_TIMESTAMP
REPOSITORY_REPOMD_CHECKSUM = _solv.REPOSITORY_REPOMD_CHECKSUM
REPOSITORY_REPOMD_OPENCHECKSUM = _solv.REPOSITORY_REPOMD_OPENCHECKSUM
REPOSITORY_REPOMD_SIZE = _solv.REPOSITORY_REPOMD_SIZE
PUBKEY_KEYID = _solv.PUBKEY_KEYID
PUBKEY_FINGERPRINT = _solv.PUBKEY_FINGERPRINT
PUBKEY_EXPIRES = _solv.PUBKEY_EXPIRES
PUBKEY_SIGNATURES = _solv.PUBKEY_SIGNATURES
PUBKEY_DATA = _solv.PUBKEY_DATA
PUBKEY_SUBKEYOF = _solv.PUBKEY_SUBKEYOF
SIGNATURE_ISSUER = _solv.SIGNATURE_ISSUER
SIGNATURE_TIME = _solv.SIGNATURE_TIME
SIGNATURE_EXPIRES = _solv.SIGNATURE_EXPIRES
SIGNATURE_DATA = _solv.SIGNATURE_DATA
PRODUCT_REGISTER_FLAVOR = _solv.PRODUCT_REGISTER_FLAVOR
SOLVABLE_INSTALLSTATUS = _solv.SOLVABLE_INSTALLSTATUS
SOLVABLE_PREREQ_IGNOREINST = _solv.SOLVABLE_PREREQ_IGNOREINST
UPDATE_STATUS = _solv.UPDATE_STATUS
LIBSOLV_SELF_DESTRUCT_PKG = _solv.LIBSOLV_SELF_DESTRUCT_PKG
ID_NUM_INTERNAL = _solv.ID_NUM_INTERNAL
SOLVID_META = _solv.SOLVID_META
SOLVID_POS = _solv.SOLVID_POS
REL_EQ = _solv.REL_EQ
REL_GT = _solv.REL_GT
REL_LT = _solv.REL_LT
REL_AND = _solv.REL_AND
REL_OR = _solv.REL_OR
REL_WITH = _solv.REL_WITH
REL_NAMESPACE = _solv.REL_NAMESPACE
REL_ARCH = _solv.REL_ARCH
REL_FILECONFLICT = _solv.REL_FILECONFLICT
REL_COND = _solv.REL_COND
REL_COMPAT = _solv.REL_COMPAT
REL_KIND = _solv.REL_KIND
REL_MULTIARCH = _solv.REL_MULTIARCH
REL_ELSE = _solv.REL_ELSE
REL_ERROR = _solv.REL_ERROR
REL_WITHOUT = _solv.REL_WITHOUT
REL_UNLESS = _solv.REL_UNLESS
class Selection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Selection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Selection, name)
    __swig_getmethods__["pool"] = _solv.Selection_pool_get
    if _newclass:
        pool = _swig_property(_solv.Selection_pool_get)
    SELECTION_NAME = _solv.Selection_SELECTION_NAME
    SELECTION_PROVIDES = _solv.Selection_SELECTION_PROVIDES
    SELECTION_FILELIST = _solv.Selection_SELECTION_FILELIST
    SELECTION_CANON = _solv.Selection_SELECTION_CANON
    SELECTION_DOTARCH = _solv.Selection_SELECTION_DOTARCH
    SELECTION_REL = _solv.Selection_SELECTION_REL
    SELECTION_INSTALLED_ONLY = _solv.Selection_SELECTION_INSTALLED_ONLY
    SELECTION_GLOB = _solv.Selection_SELECTION_GLOB
    SELECTION_FLAT = _solv.Selection_SELECTION_FLAT
    SELECTION_NOCASE = _solv.Selection_SELECTION_NOCASE
    SELECTION_SKIP_KIND = _solv.Selection_SELECTION_SKIP_KIND
    SELECTION_MATCH_DEPSTR = _solv.Selection_SELECTION_MATCH_DEPSTR
    SELECTION_SOURCE_ONLY = _solv.Selection_SELECTION_SOURCE_ONLY
    SELECTION_WITH_SOURCE = _solv.Selection_SELECTION_WITH_SOURCE
    SELECTION_WITH_DISABLED = _solv.Selection_SELECTION_WITH_DISABLED
    SELECTION_WITH_BADARCH = _solv.Selection_SELECTION_WITH_BADARCH
    SELECTION_WITH_ALL = _solv.Selection_SELECTION_WITH_ALL
    SELECTION_ADD = _solv.Selection_SELECTION_ADD
    SELECTION_SUBTRACT = _solv.Selection_SELECTION_SUBTRACT
    SELECTION_FILTER = _solv.Selection_SELECTION_FILTER
    SELECTION_FILTER_KEEP_IFEMPTY = _solv.Selection_SELECTION_FILTER_KEEP_IFEMPTY
    SELECTION_FILTER_SWAPPED = _solv.Selection_SELECTION_FILTER_SWAPPED

    def __init__(self, pool):
        this = _solv.new_Selection(pool)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _solv.delete_Selection
    __del__ = lambda self: None

    def flags(self):
        return _solv.Selection_flags(self)

    def isempty(self):
        return _solv.Selection_isempty(self)

    def clone(self, flags=0):
        return _solv.Selection_clone(self, flags)

    def filter(self, lsel):
        return _solv.Selection_filter(self, lsel)

    def add(self, lsel):
        return _solv.Selection_add(self, lsel)

    def add_raw(self, how, what):
        return _solv.Selection_add_raw(self, how, what)

    def subtract(self, lsel):
        return _solv.Selection_subtract(self, lsel)

    def select(self, name, flags):
        return _solv.Selection_select(self, name, flags)

    def matchdeps(self, name, flags, keyname, marker=-1):
        return _solv.Selection_matchdeps(self, name, flags, keyname, marker)

    def matchdepid(self, dep, flags, keyname, marker=-1):
        return _solv.Selection_matchdepid(self, dep, flags, keyname, marker)

    def jobs(self, flags):
        return _solv.Selection_jobs(self, flags)

    def solvables(self):
        return _solv.Selection_solvables(self)

    def __str__(self):
        return _solv.Selection___str__(self)

    def __repr__(self):
        return _solv.Selection___repr__(self)
Selection_swigregister = _solv.Selection_swigregister
Selection_swigregister(Selection)

class Dep(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Dep, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Dep, name)
    __swig_getmethods__["pool"] = _solv.Dep_pool_get
    if _newclass:
        pool = _swig_property(_solv.Dep_pool_get)
    __swig_getmethods__["id"] = _solv.Dep_id_get
    if _newclass:
        id = _swig_property(_solv.Dep_id_get)

    def __init__(self, pool, id):
        this = _solv.new_Dep(pool, id)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def Rel(self, flags, evrid, create=True):
        return _solv.Dep_Rel(self, flags, evrid, create)

    def Selection_name(self, setflags=0):
        return _solv.Dep_Selection_name(self, setflags)

    def Selection_provides(self, setflags=0):
        return _solv.Dep_Selection_provides(self, setflags)

    def str(self):
        return _solv.Dep_str(self)

    def __eq__(self, s):
        return _solv.Dep___eq__(self, s)

    def __ne__(self, s):
        return _solv.Dep___ne__(self, s)

    def __hash__(self):
        return _solv.Dep___hash__(self)

    def __str__(self):
        return _solv.Dep___str__(self)

    def __repr__(self):
        return _solv.Dep___repr__(self)
    __swig_destroy__ = _solv.delete_Dep
    __del__ = lambda self: None
Dep_swigregister = _solv.Dep_swigregister
Dep_swigregister(Dep)

class Dataiterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Dataiterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Dataiterator, name)
    __repr__ = _swig_repr
    SEARCH_STRING = _solv.Dataiterator_SEARCH_STRING
    SEARCH_STRINGSTART = _solv.Dataiterator_SEARCH_STRINGSTART
    SEARCH_STRINGEND = _solv.Dataiterator_SEARCH_STRINGEND
    SEARCH_SUBSTRING = _solv.Dataiterator_SEARCH_SUBSTRING
    SEARCH_GLOB = _solv.Dataiterator_SEARCH_GLOB
    SEARCH_REGEX = _solv.Dataiterator_SEARCH_REGEX
    SEARCH_NOCASE = _solv.Dataiterator_SEARCH_NOCASE
    SEARCH_FILES = _solv.Dataiterator_SEARCH_FILES
    SEARCH_COMPLETE_FILELIST = _solv.Dataiterator_SEARCH_COMPLETE_FILELIST
    SEARCH_CHECKSUMS = _solv.Dataiterator_SEARCH_CHECKSUMS

    def __init__(self, pool, repo, p, key, match, flags):
        this = _solv.new_Dataiterator(pool, repo, p, key, match, flags)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _solv.delete_Dataiterator
    __del__ = lambda self: None

    def __iter__(self): return self


    def next(self):
        return _solv.Dataiterator_next(self)

    def prepend_keyname(self, key):
        return _solv.Dataiterator_prepend_keyname(self, key)

    def skip_solvable(self):
        return _solv.Dataiterator_skip_solvable(self)
Dataiterator_swigregister = _solv.Dataiterator_swigregister
Dataiterator_swigregister(Dataiterator)

class XSolvable(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, XSolvable, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, XSolvable, name)
    __swig_getmethods__["pool"] = _solv.XSolvable_pool_get
    if _newclass:
        pool = _swig_property(_solv.XSolvable_pool_get)
    __swig_getmethods__["id"] = _solv.XSolvable_id_get
    if _newclass:
        id = _swig_property(_solv.XSolvable_id_get)

    def __init__(self, pool, id):
        this = _solv.new_XSolvable(pool, id)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def str(self):
        return _solv.XSolvable_str(self)

    def lookup_str(self, keyname):
        return _solv.XSolvable_lookup_str(self, keyname)

    def lookup_id(self, keyname):
        return _solv.XSolvable_lookup_id(self, keyname)

    def lookup_num(self, keyname, notfound=0):
        return _solv.XSolvable_lookup_num(self, keyname, notfound)

    def lookup_void(self, keyname):
        return _solv.XSolvable_lookup_void(self, keyname)

    def lookup_checksum(self, keyname):
        return _solv.XSolvable_lookup_checksum(self, keyname)

    def lookup_idarray(self, keyname, marker=-1):
        return _solv.XSolvable_lookup_idarray(self, keyname, marker)

    def lookup_deparray(self, keyname, marker=-1):
        return _solv.XSolvable_lookup_deparray(self, keyname, marker)

    def lookup_location(self):
        return _solv.XSolvable_lookup_location(self)

    def lookup_sourcepkg(self):
        return _solv.XSolvable_lookup_sourcepkg(self)

    def Dataiterator(self, key, match=None, flags=0):
        return _solv.XSolvable_Dataiterator(self, key, match, flags)

    def installable(self):
        return _solv.XSolvable_installable(self)

    def isinstalled(self):
        return _solv.XSolvable_isinstalled(self)
    __swig_setmethods__["name"] = _solv.XSolvable_name_set
    __swig_getmethods__["name"] = _solv.XSolvable_name_get
    if _newclass:
        name = _swig_property(_solv.XSolvable_name_get, _solv.XSolvable_name_set)
    __swig_setmethods__["nameid"] = _solv.XSolvable_nameid_set
    __swig_getmethods__["nameid"] = _solv.XSolvable_nameid_get
    if _newclass:
        nameid = _swig_property(_solv.XSolvable_nameid_get, _solv.XSolvable_nameid_set)
    __swig_setmethods__["evr"] = _solv.XSolvable_evr_set
    __swig_getmethods__["evr"] = _solv.XSolvable_evr_get
    if _newclass:
        evr = _swig_property(_solv.XSolvable_evr_get, _solv.XSolvable_evr_set)
    __swig_setmethods__["evrid"] = _solv.XSolvable_evrid_set
    __swig_getmethods__["evrid"] = _solv.XSolvable_evrid_get
    if _newclass:
        evrid = _swig_property(_solv.XSolvable_evrid_get, _solv.XSolvable_evrid_set)
    __swig_setmethods__["arch"] = _solv.XSolvable_arch_set
    __swig_getmethods__["arch"] = _solv.XSolvable_arch_get
    if _newclass:
        arch = _swig_property(_solv.XSolvable_arch_get, _solv.XSolvable_arch_set)
    __swig_setmethods__["archid"] = _solv.XSolvable_archid_set
    __swig_getmethods__["archid"] = _solv.XSolvable_archid_get
    if _newclass:
        archid = _swig_property(_solv.XSolvable_archid_get, _solv.XSolvable_archid_set)
    __swig_setmethods__["vendor"] = _solv.XSolvable_vendor_set
    __swig_getmethods__["vendor"] = _solv.XSolvable_vendor_get
    if _newclass:
        vendor = _swig_property(_solv.XSolvable_vendor_get, _solv.XSolvable_vendor_set)
    __swig_setmethods__["vendorid"] = _solv.XSolvable_vendorid_set
    __swig_getmethods__["vendorid"] = _solv.XSolvable_vendorid_get
    if _newclass:
        vendorid = _swig_property(_solv.XSolvable_vendorid_get, _solv.XSolvable_vendorid_set)
    __swig_getmethods__["repo"] = _solv.XSolvable_repo_get
    if _newclass:
        repo = _swig_property(_solv.XSolvable_repo_get)

    def add_provides(self, id, marker=-1):
        return _solv.XSolvable_add_provides(self, id, marker)

    def add_obsoletes(self, id):
        return _solv.XSolvable_add_obsoletes(self, id)

    def add_conflicts(self, id):
        return _solv.XSolvable_add_conflicts(self, id)

    def add_requires(self, id, marker=-1):
        return _solv.XSolvable_add_requires(self, id, marker)

    def add_recommends(self, id):
        return _solv.XSolvable_add_recommends(self, id)

    def add_suggests(self, id):
        return _solv.XSolvable_add_suggests(self, id)

    def add_supplements(self, id):
        return _solv.XSolvable_add_supplements(self, id)

    def add_enhances(self, id):
        return _solv.XSolvable_add_enhances(self, id)

    def unset(self, keyname):
        return _solv.XSolvable_unset(self, keyname)

    def add_deparray(self, keyname, id, marker=-1):
        return _solv.XSolvable_add_deparray(self, keyname, id, marker)

    def Selection(self, setflags=0):
        return _solv.XSolvable_Selection(self, setflags)

    def identical(self, s2):
        return _solv.XSolvable_identical(self, s2)

    def evrcmp(self, s2):
        return _solv.XSolvable_evrcmp(self, s2)

    def matchesdep(self, keyname, id, marker=-1):
        return _solv.XSolvable_matchesdep(self, keyname, id, marker)

    def __eq__(self, s):
        return _solv.XSolvable___eq__(self, s)

    def __ne__(self, s):
        return _solv.XSolvable___ne__(self, s)

    def __hash__(self):
        return _solv.XSolvable___hash__(self)

    def __str__(self):
        return _solv.XSolvable___str__(self)

    def __repr__(self):
        return _solv.XSolvable___repr__(self)
    __swig_destroy__ = _solv.delete_XSolvable
    __del__ = lambda self: None
XSolvable_swigregister = _solv.XSolvable_swigregister
XSolvable_swigregister(XSolvable)

class Ruleinfo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Ruleinfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Ruleinfo, name)
    __repr__ = _swig_repr
    __swig_getmethods__["solv"] = _solv.Ruleinfo_solv_get
    if _newclass:
        solv = _swig_property(_solv.Ruleinfo_solv_get)
    __swig_getmethods__["type"] = _solv.Ruleinfo_type_get
    if _newclass:
        type = _swig_property(_solv.Ruleinfo_type_get)
    __swig_getmethods__["dep_id"] = _solv.Ruleinfo_dep_id_get
    if _newclass:
        dep_id = _swig_property(_solv.Ruleinfo_dep_id_get)

    def __init__(self, r, type, source, target, dep_id):
        this = _solv.new_Ruleinfo(r, type, source, target, dep_id)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_getmethods__["solvable"] = _solv.Ruleinfo_solvable_get
    if _newclass:
        solvable = _swig_property(_solv.Ruleinfo_solvable_get)
    __swig_getmethods__["othersolvable"] = _solv.Ruleinfo_othersolvable_get
    if _newclass:
        othersolvable = _swig_property(_solv.Ruleinfo_othersolvable_get)
    __swig_getmethods__["dep"] = _solv.Ruleinfo_dep_get
    if _newclass:
        dep = _swig_property(_solv.Ruleinfo_dep_get)

    def problemstr(self):
        return _solv.Ruleinfo_problemstr(self)
    __swig_destroy__ = _solv.delete_Ruleinfo
    __del__ = lambda self: None
Ruleinfo_swigregister = _solv.Ruleinfo_swigregister
Ruleinfo_swigregister(Ruleinfo)

class XRule(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, XRule, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, XRule, name)
    __swig_getmethods__["solv"] = _solv.XRule_solv_get
    if _newclass:
        solv = _swig_property(_solv.XRule_solv_get)
    __swig_getmethods__["id"] = _solv.XRule_id_get
    if _newclass:
        id = _swig_property(_solv.XRule_id_get)

    def __init__(self, solv, id):
        this = _solv.new_XRule(solv, id)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_getmethods__["type"] = _solv.XRule_type_get
    if _newclass:
        type = _swig_property(_solv.XRule_type_get)

    def info(self):
        return _solv.XRule_info(self)

    def allinfos(self):
        return _solv.XRule_allinfos(self)

    def __eq__(self, xr):
        return _solv.XRule___eq__(self, xr)

    def __ne__(self, xr):
        return _solv.XRule___ne__(self, xr)

    def __hash__(self):
        return _solv.XRule___hash__(self)

    def __repr__(self):
        return _solv.XRule___repr__(self)
    __swig_destroy__ = _solv.delete_XRule
    __del__ = lambda self: None
XRule_swigregister = _solv.XRule_swigregister
XRule_swigregister(XRule)

class XRepodata(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, XRepodata, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, XRepodata, name)
    __swig_getmethods__["repo"] = _solv.XRepodata_repo_get
    if _newclass:
        repo = _swig_property(_solv.XRepodata_repo_get)
    __swig_getmethods__["id"] = _solv.XRepodata_id_get
    if _newclass:
        id = _swig_property(_solv.XRepodata_id_get)

    def __init__(self, repo, id):
        this = _solv.new_XRepodata(repo, id)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def new_handle(self):
        return _solv.XRepodata_new_handle(self)

    def set_id(self, solvid, keyname, id):
        return _solv.XRepodata_set_id(self, solvid, keyname, id)

    def set_str(self, solvid, keyname, str):
        return _solv.XRepodata_set_str(self, solvid, keyname, str)

    def set_poolstr(self, solvid, keyname, str):
        return _solv.XRepodata_set_poolstr(self, solvid, keyname, str)

    def add_idarray(self, solvid, keyname, id):
        return _solv.XRepodata_add_idarray(self, solvid, keyname, id)

    def add_flexarray(self, solvid, keyname, handle):
        return _solv.XRepodata_add_flexarray(self, solvid, keyname, handle)

    def set_checksum(self, solvid, keyname, chksum):
        return _solv.XRepodata_set_checksum(self, solvid, keyname, chksum)

    def set_sourcepkg(self, solvid, sourcepkg):
        return _solv.XRepodata_set_sourcepkg(self, solvid, sourcepkg)

    def lookup_str(self, solvid, keyname):
        return _solv.XRepodata_lookup_str(self, solvid, keyname)

    def lookup_idarray(self, solvid, keyname):
        return _solv.XRepodata_lookup_idarray(self, solvid, keyname)

    def lookup_checksum(self, solvid, keyname):
        return _solv.XRepodata_lookup_checksum(self, solvid, keyname)

    def internalize(self):
        return _solv.XRepodata_internalize(self)

    def create_stubs(self):
        return _solv.XRepodata_create_stubs(self)

    def write(self, fp):
        return _solv.XRepodata_write(self, fp)

    def str2dir(self, dir, create=True):
        return _solv.XRepodata_str2dir(self, dir, create)

    def dir2str(self, did, suf=None):
        return _solv.XRepodata_dir2str(self, did, suf)

    def add_dirstr(self, solvid, keyname, dir, str):
        return _solv.XRepodata_add_dirstr(self, solvid, keyname, dir, str)

    def add_solv(self, fp, flags=0):
        return _solv.XRepodata_add_solv(self, fp, flags)

    def extend_to_repo(self):
        return _solv.XRepodata_extend_to_repo(self)

    def __eq__(self, xr):
        return _solv.XRepodata___eq__(self, xr)

    def __ne__(self, xr):
        return _solv.XRepodata___ne__(self, xr)

    def __hash__(self):
        return _solv.XRepodata___hash__(self)

    def __repr__(self):
        return _solv.XRepodata___repr__(self)
    __swig_destroy__ = _solv.delete_XRepodata
    __del__ = lambda self: None
XRepodata_swigregister = _solv.XRepodata_swigregister
XRepodata_swigregister(XRepodata)

class Pool_solvable_iterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Pool_solvable_iterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Pool_solvable_iterator, name)
    __repr__ = _swig_repr

    def __init__(self, pool):
        this = _solv.new_Pool_solvable_iterator(pool)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __iter__(self): return self


    def next(self):
        return _solv.Pool_solvable_iterator_next(self)

    def __getitem__(self, key):
        return _solv.Pool_solvable_iterator___getitem__(self, key)

    def __len__(self):
        return _solv.Pool_solvable_iterator___len__(self)
    __swig_destroy__ = _solv.delete_Pool_solvable_iterator
    __del__ = lambda self: None
Pool_solvable_iterator_swigregister = _solv.Pool_solvable_iterator_swigregister
Pool_solvable_iterator_swigregister(Pool_solvable_iterator)

class Pool_repo_iterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Pool_repo_iterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Pool_repo_iterator, name)
    __repr__ = _swig_repr

    def __init__(self, pool):
        this = _solv.new_Pool_repo_iterator(pool)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __iter__(self): return self


    def next(self):
        return _solv.Pool_repo_iterator_next(self)

    def __getitem__(self, key):
        return _solv.Pool_repo_iterator___getitem__(self, key)

    def __len__(self):
        return _solv.Pool_repo_iterator___len__(self)
    __swig_destroy__ = _solv.delete_Pool_repo_iterator
    __del__ = lambda self: None
Pool_repo_iterator_swigregister = _solv.Pool_repo_iterator_swigregister
Pool_repo_iterator_swigregister(Pool_repo_iterator)

class Repo_solvable_iterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Repo_solvable_iterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Repo_solvable_iterator, name)
    __repr__ = _swig_repr

    def __init__(self, repo):
        this = _solv.new_Repo_solvable_iterator(repo)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __iter__(self): return self


    def next(self):
        return _solv.Repo_solvable_iterator_next(self)

    def __getitem__(self, key):
        return _solv.Repo_solvable_iterator___getitem__(self, key)

    def __len__(self):
        return _solv.Repo_solvable_iterator___len__(self)
    __swig_destroy__ = _solv.delete_Repo_solvable_iterator
    __del__ = lambda self: None
Repo_solvable_iterator_swigregister = _solv.Repo_solvable_iterator_swigregister
Repo_solvable_iterator_swigregister(Repo_solvable_iterator)

class Datamatch(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Datamatch, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Datamatch, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_getmethods__["pool"] = _solv.Datamatch_pool_get
    if _newclass:
        pool = _swig_property(_solv.Datamatch_pool_get)
    __swig_getmethods__["repo"] = _solv.Datamatch_repo_get
    if _newclass:
        repo = _swig_property(_solv.Datamatch_repo_get)
    __swig_getmethods__["solvid"] = _solv.Datamatch_solvid_get
    if _newclass:
        solvid = _swig_property(_solv.Datamatch_solvid_get)
    __swig_destroy__ = _solv.delete_Datamatch
    __del__ = lambda self: None
    __swig_getmethods__["solvable"] = _solv.Datamatch_solvable_get
    if _newclass:
        solvable = _swig_property(_solv.Datamatch_solvable_get)
    __swig_getmethods__["key_id"] = _solv.Datamatch_key_id_get
    if _newclass:
        key_id = _swig_property(_solv.Datamatch_key_id_get)
    __swig_getmethods__["key_idstr"] = _solv.Datamatch_key_idstr_get
    if _newclass:
        key_idstr = _swig_property(_solv.Datamatch_key_idstr_get)
    __swig_getmethods__["type_id"] = _solv.Datamatch_type_id_get
    if _newclass:
        type_id = _swig_property(_solv.Datamatch_type_id_get)
    __swig_getmethods__["type_idstr"] = _solv.Datamatch_type_idstr_get
    if _newclass:
        type_idstr = _swig_property(_solv.Datamatch_type_idstr_get)
    __swig_getmethods__["id"] = _solv.Datamatch_id_get
    if _newclass:
        id = _swig_property(_solv.Datamatch_id_get)
    __swig_getmethods__["idstr"] = _solv.Datamatch_idstr_get
    if _newclass:
        idstr = _swig_property(_solv.Datamatch_idstr_get)
    __swig_getmethods__["str"] = _solv.Datamatch_str_get
    if _newclass:
        str = _swig_property(_solv.Datamatch_str_get)
    __swig_getmethods__["binary"] = _solv.Datamatch_binary_get
    if _newclass:
        binary = _swig_property(_solv.Datamatch_binary_get)
    __swig_getmethods__["num"] = _solv.Datamatch_num_get
    if _newclass:
        num = _swig_property(_solv.Datamatch_num_get)
    __swig_getmethods__["num2"] = _solv.Datamatch_num2_get
    if _newclass:
        num2 = _swig_property(_solv.Datamatch_num2_get)

    def pos(self):
        return _solv.Datamatch_pos(self)

    def parentpos(self):
        return _solv.Datamatch_parentpos(self)

    def __str__(self):
        return _solv.Datamatch___str__(self)
Datamatch_swigregister = _solv.Datamatch_swigregister
Datamatch_swigregister(Datamatch)

class Datapos(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Datapos, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Datapos, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_getmethods__["repo"] = _solv.Datapos_repo_get
    if _newclass:
        repo = _swig_property(_solv.Datapos_repo_get)

    def lookup_id(self, keyname):
        return _solv.Datapos_lookup_id(self, keyname)

    def lookup_str(self, keyname):
        return _solv.Datapos_lookup_str(self, keyname)

    def lookup_num(self, keyname, notfound=0):
        return _solv.Datapos_lookup_num(self, keyname, notfound)

    def lookup_void(self, keyname):
        return _solv.Datapos_lookup_void(self, keyname)

    def lookup_checksum(self, keyname):
        return _solv.Datapos_lookup_checksum(self, keyname)

    def lookup_deltaseq(self):
        return _solv.Datapos_lookup_deltaseq(self)

    def lookup_deltalocation(self):
        return _solv.Datapos_lookup_deltalocation(self)

    def lookup_idarray(self, keyname):
        return _solv.Datapos_lookup_idarray(self, keyname)

    def Dataiterator(self, key, match=None, flags=0):
        return _solv.Datapos_Dataiterator(self, key, match, flags)
    __swig_destroy__ = _solv.delete_Datapos
    __del__ = lambda self: None
Datapos_swigregister = _solv.Datapos_swigregister
Datapos_swigregister(Datapos)

class Job(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Job, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Job, name)
    __swig_getmethods__["pool"] = _solv.Job_pool_get
    if _newclass:
        pool = _swig_property(_solv.Job_pool_get)
    __swig_setmethods__["how"] = _solv.Job_how_set
    __swig_getmethods__["how"] = _solv.Job_how_get
    if _newclass:
        how = _swig_property(_solv.Job_how_get, _solv.Job_how_set)
    __swig_setmethods__["what"] = _solv.Job_what_set
    __swig_getmethods__["what"] = _solv.Job_what_get
    if _newclass:
        what = _swig_property(_solv.Job_what_get, _solv.Job_what_set)
    SOLVER_SOLVABLE = _solv.Job_SOLVER_SOLVABLE
    SOLVER_SOLVABLE_NAME = _solv.Job_SOLVER_SOLVABLE_NAME
    SOLVER_SOLVABLE_PROVIDES = _solv.Job_SOLVER_SOLVABLE_PROVIDES
    SOLVER_SOLVABLE_ONE_OF = _solv.Job_SOLVER_SOLVABLE_ONE_OF
    SOLVER_SOLVABLE_REPO = _solv.Job_SOLVER_SOLVABLE_REPO
    SOLVER_SOLVABLE_ALL = _solv.Job_SOLVER_SOLVABLE_ALL
    SOLVER_SELECTMASK = _solv.Job_SOLVER_SELECTMASK
    SOLVER_NOOP = _solv.Job_SOLVER_NOOP
    SOLVER_INSTALL = _solv.Job_SOLVER_INSTALL
    SOLVER_ERASE = _solv.Job_SOLVER_ERASE
    SOLVER_UPDATE = _solv.Job_SOLVER_UPDATE
    SOLVER_WEAKENDEPS = _solv.Job_SOLVER_WEAKENDEPS
    SOLVER_MULTIVERSION = _solv.Job_SOLVER_MULTIVERSION
    SOLVER_LOCK = _solv.Job_SOLVER_LOCK
    SOLVER_DISTUPGRADE = _solv.Job_SOLVER_DISTUPGRADE
    SOLVER_VERIFY = _solv.Job_SOLVER_VERIFY
    SOLVER_DROP_ORPHANED = _solv.Job_SOLVER_DROP_ORPHANED
    SOLVER_USERINSTALLED = _solv.Job_SOLVER_USERINSTALLED
    SOLVER_ALLOWUNINSTALL = _solv.Job_SOLVER_ALLOWUNINSTALL
    SOLVER_FAVOR = _solv.Job_SOLVER_FAVOR
    SOLVER_DISFAVOR = _solv.Job_SOLVER_DISFAVOR
    SOLVER_JOBMASK = _solv.Job_SOLVER_JOBMASK
    SOLVER_WEAK = _solv.Job_SOLVER_WEAK
    SOLVER_ESSENTIAL = _solv.Job_SOLVER_ESSENTIAL
    SOLVER_CLEANDEPS = _solv.Job_SOLVER_CLEANDEPS
    SOLVER_FORCEBEST = _solv.Job_SOLVER_FORCEBEST
    SOLVER_TARGETED = _solv.Job_SOLVER_TARGETED
    SOLVER_NOTBYUSER = _solv.Job_SOLVER_NOTBYUSER
    SOLVER_SETEV = _solv.Job_SOLVER_SETEV
    SOLVER_SETEVR = _solv.Job_SOLVER_SETEVR
    SOLVER_SETARCH = _solv.Job_SOLVER_SETARCH
    SOLVER_SETVENDOR = _solv.Job_SOLVER_SETVENDOR
    SOLVER_SETREPO = _solv.Job_SOLVER_SETREPO
    SOLVER_SETNAME = _solv.Job_SOLVER_SETNAME
    SOLVER_NOAUTOSET = _solv.Job_SOLVER_NOAUTOSET
    SOLVER_SETMASK = _solv.Job_SOLVER_SETMASK

    def __init__(self, pool, how, what):
        this = _solv.new_Job(pool, how, what)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def solvables(self):
        return _solv.Job_solvables(self)

    def isemptyupdate(self):
        return _solv.Job_isemptyupdate(self)

    def __eq__(self, j):
        return _solv.Job___eq__(self, j)

    def __ne__(self, j):
        return _solv.Job___ne__(self, j)

    def __str__(self):
        return _solv.Job___str__(self)

    def __repr__(self):
        return _solv.Job___repr__(self)
    __swig_destroy__ = _solv.delete_Job
    __del__ = lambda self: None
Job_swigregister = _solv.Job_swigregister
Job_swigregister(Job)

class Pool(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Pool, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Pool, name)
    __repr__ = _swig_repr
    POOL_FLAG_PROMOTEEPOCH = _solv.Pool_POOL_FLAG_PROMOTEEPOCH
    POOL_FLAG_FORBIDSELFCONFLICTS = _solv.Pool_POOL_FLAG_FORBIDSELFCONFLICTS
    POOL_FLAG_OBSOLETEUSESPROVIDES = _solv.Pool_POOL_FLAG_OBSOLETEUSESPROVIDES
    POOL_FLAG_IMPLICITOBSOLETEUSESPROVIDES = _solv.Pool_POOL_FLAG_IMPLICITOBSOLETEUSESPROVIDES
    POOL_FLAG_OBSOLETEUSESCOLORS = _solv.Pool_POOL_FLAG_OBSOLETEUSESCOLORS
    POOL_FLAG_IMPLICITOBSOLETEUSESCOLORS = _solv.Pool_POOL_FLAG_IMPLICITOBSOLETEUSESCOLORS
    POOL_FLAG_NOINSTALLEDOBSOLETES = _solv.Pool_POOL_FLAG_NOINSTALLEDOBSOLETES
    POOL_FLAG_HAVEDISTEPOCH = _solv.Pool_POOL_FLAG_HAVEDISTEPOCH
    POOL_FLAG_NOOBSOLETESMULTIVERSION = _solv.Pool_POOL_FLAG_NOOBSOLETESMULTIVERSION
    DISTTYPE_RPM = _solv.Pool_DISTTYPE_RPM
    DISTTYPE_DEB = _solv.Pool_DISTTYPE_DEB
    DISTTYPE_ARCH = _solv.Pool_DISTTYPE_ARCH
    DISTTYPE_HAIKU = _solv.Pool_DISTTYPE_HAIKU

    def __init__(self):
        this = _solv.new_Pool()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def setdisttype(self, disttype):
        return _solv.Pool_setdisttype(self, disttype)

    def set_debuglevel(self, level):
        return _solv.Pool_set_debuglevel(self, level)

    def set_flag(self, flag, value):
        return _solv.Pool_set_flag(self, flag, value)

    def get_flag(self, flag):
        return _solv.Pool_get_flag(self, flag)

    def set_rootdir(self, rootdir):
        return _solv.Pool_set_rootdir(self, rootdir)

    def get_rootdir(self, flag):
        return _solv.Pool_get_rootdir(self, flag)

    def clr_loadcallback(self):
        return _solv.Pool_clr_loadcallback(self)

    def set_loadcallback(self, callable):
        return _solv.Pool_set_loadcallback(self, callable)
    __swig_destroy__ = _solv.delete_Pool
    __del__ = lambda self: None

    def free(self):
        return _solv.Pool_free(self)

    def disown(self):
        return _solv.Pool_disown(self)
    __swig_setmethods__["appdata"] = _solv.Pool_appdata_set
    __swig_getmethods__["appdata"] = _solv.Pool_appdata_get
    if _newclass:
        appdata = _swig_property(_solv.Pool_appdata_get, _solv.Pool_appdata_set)

    def appdata_disown(self):
        return _solv.Pool_appdata_disown(self)

    def str2id(self, str, create=True):
        return _solv.Pool_str2id(self, str, create)

    def Dep(self, str, create=True):
        return _solv.Pool_Dep(self, str, create)

    def id2str(self, id):
        return _solv.Pool_id2str(self, id)

    def dep2str(self, id):
        return _solv.Pool_dep2str(self, id)

    def rel2id(self, name, evr, flags, create=True):
        return _solv.Pool_rel2id(self, name, evr, flags, create)

    def id2langid(self, id, lang, create=True):
        return _solv.Pool_id2langid(self, id, lang, create)

    def setarch(self, arch=None):
        return _solv.Pool_setarch(self, arch)

    def add_repo(self, name):
        return _solv.Pool_add_repo(self, name)

    def lookup_str(self, entry, keyname):
        return _solv.Pool_lookup_str(self, entry, keyname)

    def lookup_id(self, entry, keyname):
        return _solv.Pool_lookup_id(self, entry, keyname)

    def lookup_num(self, entry, keyname, notfound=0):
        return _solv.Pool_lookup_num(self, entry, keyname, notfound)

    def lookup_void(self, entry, keyname):
        return _solv.Pool_lookup_void(self, entry, keyname)

    def lookup_checksum(self, entry, keyname):
        return _solv.Pool_lookup_checksum(self, entry, keyname)

    def Dataiterator(self, key, match=None, flags=0):
        return _solv.Pool_Dataiterator(self, key, match, flags)

    def Dataiterator_solvid(self, p, key, match=None, flags=0):
        return _solv.Pool_Dataiterator_solvid(self, p, key, match, flags)

    def solvid2str(self, solvid):
        return _solv.Pool_solvid2str(self, solvid)

    def addfileprovides(self):
        return _solv.Pool_addfileprovides(self)

    def addfileprovides_queue(self):
        return _solv.Pool_addfileprovides_queue(self)

    def createwhatprovides(self):
        return _solv.Pool_createwhatprovides(self)

    def id2solvable(self, id):
        return _solv.Pool_id2solvable(self, id)
    __swig_getmethods__["solvables"] = _solv.Pool_solvables_get
    if _newclass:
        solvables = _swig_property(_solv.Pool_solvables_get)

    def solvables_iter(self):
        return _solv.Pool_solvables_iter(self)

    def id2repo(self, id):
        return _solv.Pool_id2repo(self, id)
    __swig_getmethods__["repos"] = _solv.Pool_repos_get
    if _newclass:
        repos = _swig_property(_solv.Pool_repos_get)

    def repos_iter(self):
        return _solv.Pool_repos_iter(self)
    __swig_setmethods__["installed"] = _solv.Pool_installed_set
    __swig_getmethods__["installed"] = _solv.Pool_installed_get
    if _newclass:
        installed = _swig_property(_solv.Pool_installed_get, _solv.Pool_installed_set)
    __swig_getmethods__["errstr"] = _solv.Pool_errstr_get
    if _newclass:
        errstr = _swig_property(_solv.Pool_errstr_get)

    def matchprovidingids(self, match, flags):
        return _solv.Pool_matchprovidingids(self, match, flags)

    def Job(self, how, what):
        return _solv.Pool_Job(self, how, what)

    def whatprovides(self, dep):
        return _solv.Pool_whatprovides(self, dep)

    def towhatprovides(self, q):
        return _solv.Pool_towhatprovides(self, q)

    def set_namespaceproviders(self, ns, evr, value=True):
        return _solv.Pool_set_namespaceproviders(self, ns, evr, value)

    def flush_namespaceproviders(self, ns, evr):
        return _solv.Pool_flush_namespaceproviders(self, ns, evr)

    def whatmatchesdep(self, keyname, dep, marker=-1):
        return _solv.Pool_whatmatchesdep(self, keyname, dep, marker)

    def isknownarch(self, id):
        return _solv.Pool_isknownarch(self, id)

    def Solver(self):
        return _solv.Pool_Solver(self)

    def Selection(self):
        return _solv.Pool_Selection(self)

    def Selection_all(self, setflags=0):
        return _solv.Pool_Selection_all(self, setflags)

    def select(self, name, flags):
        return _solv.Pool_select(self, name, flags)

    def matchdeps(self, name, flags, keyname, marker=-1):
        return _solv.Pool_matchdeps(self, name, flags, keyname, marker)

    def matchdepid(self, dep, flags, keyname, marker=-1):
        return _solv.Pool_matchdepid(self, dep, flags, keyname, marker)

    def setpooljobs_helper(self, jobs):
        return _solv.Pool_setpooljobs_helper(self, jobs)

    def getpooljobs(self):
        return _solv.Pool_getpooljobs(self)

    def setpooljobs(self, jobs):
      j = []
      for job in jobs: j += [job.how, job.what]
      self.setpooljobs_helper(j)

Pool_swigregister = _solv.Pool_swigregister
Pool_swigregister(Pool)

class Repo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Repo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Repo, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __swig_getmethods__["pool"] = _solv.Repo_pool_get
    if _newclass:
        pool = _swig_property(_solv.Repo_pool_get)
    __swig_getmethods__["name"] = _solv.Repo_name_get
    if _newclass:
        name = _swig_property(_solv.Repo_name_get)
    __swig_setmethods__["priority"] = _solv.Repo_priority_set
    __swig_getmethods__["priority"] = _solv.Repo_priority_get
    if _newclass:
        priority = _swig_property(_solv.Repo_priority_get, _solv.Repo_priority_set)
    __swig_setmethods__["subpriority"] = _solv.Repo_subpriority_set
    __swig_getmethods__["subpriority"] = _solv.Repo_subpriority_get
    if _newclass:
        subpriority = _swig_property(_solv.Repo_subpriority_get, _solv.Repo_subpriority_set)
    __swig_getmethods__["nsolvables"] = _solv.Repo_nsolvables_get
    if _newclass:
        nsolvables = _swig_property(_solv.Repo_nsolvables_get)
    REPO_REUSE_REPODATA = _solv.Repo_REPO_REUSE_REPODATA
    REPO_NO_INTERNALIZE = _solv.Repo_REPO_NO_INTERNALIZE
    REPO_LOCALPOOL = _solv.Repo_REPO_LOCALPOOL
    REPO_USE_LOADING = _solv.Repo_REPO_USE_LOADING
    REPO_EXTEND_SOLVABLES = _solv.Repo_REPO_EXTEND_SOLVABLES
    REPO_USE_ROOTDIR = _solv.Repo_REPO_USE_ROOTDIR
    REPO_NO_LOCATION = _solv.Repo_REPO_NO_LOCATION
    SOLV_ADD_NO_STUBS = _solv.Repo_SOLV_ADD_NO_STUBS
    SUSETAGS_RECORD_SHARES = _solv.Repo_SUSETAGS_RECORD_SHARES

    def free(self, reuseids=False):
        return _solv.Repo_free(self, reuseids)

    def empty(self, reuseids=False):
        return _solv.Repo_empty(self, reuseids)

    def isempty(self):
        return _solv.Repo_isempty(self)
    __swig_setmethods__["appdata"] = _solv.Repo_appdata_set
    __swig_getmethods__["appdata"] = _solv.Repo_appdata_get
    if _newclass:
        appdata = _swig_property(_solv.Repo_appdata_get, _solv.Repo_appdata_set)

    def add_solv(self, *args):
        return _solv.Repo_add_solv(self, *args)

    def add_solvable(self):
        return _solv.Repo_add_solvable(self)

    def add_rpmdb(self, flags=0):
        return _solv.Repo_add_rpmdb(self, flags)

    def add_rpmdb_reffp(self, reffp, flags=0):
        return _solv.Repo_add_rpmdb_reffp(self, reffp, flags)

    def add_rpm(self, name, flags=0):
        return _solv.Repo_add_rpm(self, name, flags)

    def add_rpmdb_pubkeys(self, flags=0):
        return _solv.Repo_add_rpmdb_pubkeys(self, flags)

    def add_pubkey(self, keyfile, flags=0):
        return _solv.Repo_add_pubkey(self, keyfile, flags)

    def add_keyring(self, fp, flags=0):
        return _solv.Repo_add_keyring(self, fp, flags)

    def add_keydir(self, keydir, suffix, flags=0):
        return _solv.Repo_add_keydir(self, keydir, suffix, flags)

    def add_rpmmd(self, fp, language, flags=0):
        return _solv.Repo_add_rpmmd(self, fp, language, flags)

    def add_repomdxml(self, fp, flags=0):
        return _solv.Repo_add_repomdxml(self, fp, flags)

    def add_updateinfoxml(self, fp, flags=0):
        return _solv.Repo_add_updateinfoxml(self, fp, flags)

    def add_deltainfoxml(self, fp, flags=0):
        return _solv.Repo_add_deltainfoxml(self, fp, flags)

    def add_susetags(self, fp, defvendor, language, flags=0):
        return _solv.Repo_add_susetags(self, fp, defvendor, language, flags)

    def add_content(self, fp, flags=0):
        return _solv.Repo_add_content(self, fp, flags)

    def add_products(self, proddir, flags=0):
        return _solv.Repo_add_products(self, proddir, flags)

    def internalize(self):
        return _solv.Repo_internalize(self)

    def write(self, fp):
        return _solv.Repo_write(self, fp)

    def write_first_repodata(self, fp):
        return _solv.Repo_write_first_repodata(self, fp)

    def Dataiterator(self, key, match=None, flags=0):
        return _solv.Repo_Dataiterator(self, key, match, flags)

    def Dataiterator_meta(self, key, match=None, flags=0):
        return _solv.Repo_Dataiterator_meta(self, key, match, flags)
    __swig_getmethods__["id"] = _solv.Repo_id_get
    if _newclass:
        id = _swig_property(_solv.Repo_id_get)
    __swig_getmethods__["solvables"] = _solv.Repo_solvables_get
    if _newclass:
        solvables = _swig_property(_solv.Repo_solvables_get)
    __swig_getmethods__["meta"] = _solv.Repo_meta_get
    if _newclass:
        meta = _swig_property(_solv.Repo_meta_get)

    def solvables_iter(self):
        return _solv.Repo_solvables_iter(self)

    def add_repodata(self, flags=0):
        return _solv.Repo_add_repodata(self, flags)

    def create_stubs(self):
        return _solv.Repo_create_stubs(self)

    def iscontiguous(self):
        return _solv.Repo_iscontiguous(self)

    def first_repodata(self):
        return _solv.Repo_first_repodata(self)

    def Selection(self, setflags=0):
        return _solv.Repo_Selection(self, setflags)

    def find_pubkey(self, keyid):
        return _solv.Repo_find_pubkey(self, keyid)

    def createshadow(self, name):
        return _solv.Repo_createshadow(self, name)

    def moveshadow(self, q):
        return _solv.Repo_moveshadow(self, q)

    def __eq__(self, repo):
        return _solv.Repo___eq__(self, repo)

    def __ne__(self, repo):
        return _solv.Repo___ne__(self, repo)

    def __hash__(self):
        return _solv.Repo___hash__(self)

    def __str__(self):
        return _solv.Repo___str__(self)

    def __repr__(self):
        return _solv.Repo___repr__(self)
Repo_swigregister = _solv.Repo_swigregister
Repo_swigregister(Repo)

class Solver(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Solver, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Solver, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_getmethods__["pool"] = _solv.Solver_pool_get
    if _newclass:
        pool = _swig_property(_solv.Solver_pool_get)
    SOLVER_RULE_UNKNOWN = _solv.Solver_SOLVER_RULE_UNKNOWN
    SOLVER_RULE_PKG = _solv.Solver_SOLVER_RULE_PKG
    SOLVER_RULE_PKG_NOT_INSTALLABLE = _solv.Solver_SOLVER_RULE_PKG_NOT_INSTALLABLE
    SOLVER_RULE_PKG_NOTHING_PROVIDES_DEP = _solv.Solver_SOLVER_RULE_PKG_NOTHING_PROVIDES_DEP
    SOLVER_RULE_PKG_REQUIRES = _solv.Solver_SOLVER_RULE_PKG_REQUIRES
    SOLVER_RULE_PKG_SELF_CONFLICT = _solv.Solver_SOLVER_RULE_PKG_SELF_CONFLICT
    SOLVER_RULE_PKG_CONFLICTS = _solv.Solver_SOLVER_RULE_PKG_CONFLICTS
    SOLVER_RULE_PKG_SAME_NAME = _solv.Solver_SOLVER_RULE_PKG_SAME_NAME
    SOLVER_RULE_PKG_OBSOLETES = _solv.Solver_SOLVER_RULE_PKG_OBSOLETES
    SOLVER_RULE_PKG_IMPLICIT_OBSOLETES = _solv.Solver_SOLVER_RULE_PKG_IMPLICIT_OBSOLETES
    SOLVER_RULE_PKG_INSTALLED_OBSOLETES = _solv.Solver_SOLVER_RULE_PKG_INSTALLED_OBSOLETES
    SOLVER_RULE_UPDATE = _solv.Solver_SOLVER_RULE_UPDATE
    SOLVER_RULE_FEATURE = _solv.Solver_SOLVER_RULE_FEATURE
    SOLVER_RULE_JOB = _solv.Solver_SOLVER_RULE_JOB
    SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP = _solv.Solver_SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP
    SOLVER_RULE_JOB_PROVIDED_BY_SYSTEM = _solv.Solver_SOLVER_RULE_JOB_PROVIDED_BY_SYSTEM
    SOLVER_RULE_JOB_UNKNOWN_PACKAGE = _solv.Solver_SOLVER_RULE_JOB_UNKNOWN_PACKAGE
    SOLVER_RULE_JOB_UNSUPPORTED = _solv.Solver_SOLVER_RULE_JOB_UNSUPPORTED
    SOLVER_RULE_DISTUPGRADE = _solv.Solver_SOLVER_RULE_DISTUPGRADE
    SOLVER_RULE_INFARCH = _solv.Solver_SOLVER_RULE_INFARCH
    SOLVER_RULE_CHOICE = _solv.Solver_SOLVER_RULE_CHOICE
    SOLVER_RULE_LEARNT = _solv.Solver_SOLVER_RULE_LEARNT
    SOLVER_SOLUTION_JOB = _solv.Solver_SOLVER_SOLUTION_JOB
    SOLVER_SOLUTION_POOLJOB = _solv.Solver_SOLVER_SOLUTION_POOLJOB
    SOLVER_SOLUTION_INFARCH = _solv.Solver_SOLVER_SOLUTION_INFARCH
    SOLVER_SOLUTION_DISTUPGRADE = _solv.Solver_SOLVER_SOLUTION_DISTUPGRADE
    SOLVER_SOLUTION_BEST = _solv.Solver_SOLVER_SOLUTION_BEST
    SOLVER_SOLUTION_ERASE = _solv.Solver_SOLVER_SOLUTION_ERASE
    SOLVER_SOLUTION_REPLACE = _solv.Solver_SOLVER_SOLUTION_REPLACE
    SOLVER_SOLUTION_REPLACE_DOWNGRADE = _solv.Solver_SOLVER_SOLUTION_REPLACE_DOWNGRADE
    SOLVER_SOLUTION_REPLACE_ARCHCHANGE = _solv.Solver_SOLVER_SOLUTION_REPLACE_ARCHCHANGE
    SOLVER_SOLUTION_REPLACE_VENDORCHANGE = _solv.Solver_SOLVER_SOLUTION_REPLACE_VENDORCHANGE
    SOLVER_SOLUTION_REPLACE_NAMECHANGE = _solv.Solver_SOLVER_SOLUTION_REPLACE_NAMECHANGE
    POLICY_ILLEGAL_DOWNGRADE = _solv.Solver_POLICY_ILLEGAL_DOWNGRADE
    POLICY_ILLEGAL_ARCHCHANGE = _solv.Solver_POLICY_ILLEGAL_ARCHCHANGE
    POLICY_ILLEGAL_VENDORCHANGE = _solv.Solver_POLICY_ILLEGAL_VENDORCHANGE
    POLICY_ILLEGAL_NAMECHANGE = _solv.Solver_POLICY_ILLEGAL_NAMECHANGE
    SOLVER_FLAG_ALLOW_DOWNGRADE = _solv.Solver_SOLVER_FLAG_ALLOW_DOWNGRADE
    SOLVER_FLAG_ALLOW_ARCHCHANGE = _solv.Solver_SOLVER_FLAG_ALLOW_ARCHCHANGE
    SOLVER_FLAG_ALLOW_VENDORCHANGE = _solv.Solver_SOLVER_FLAG_ALLOW_VENDORCHANGE
    SOLVER_FLAG_ALLOW_NAMECHANGE = _solv.Solver_SOLVER_FLAG_ALLOW_NAMECHANGE
    SOLVER_FLAG_ALLOW_UNINSTALL = _solv.Solver_SOLVER_FLAG_ALLOW_UNINSTALL
    SOLVER_FLAG_NO_UPDATEPROVIDE = _solv.Solver_SOLVER_FLAG_NO_UPDATEPROVIDE
    SOLVER_FLAG_SPLITPROVIDES = _solv.Solver_SOLVER_FLAG_SPLITPROVIDES
    SOLVER_FLAG_IGNORE_RECOMMENDED = _solv.Solver_SOLVER_FLAG_IGNORE_RECOMMENDED
    SOLVER_FLAG_ADD_ALREADY_RECOMMENDED = _solv.Solver_SOLVER_FLAG_ADD_ALREADY_RECOMMENDED
    SOLVER_FLAG_NO_INFARCHCHECK = _solv.Solver_SOLVER_FLAG_NO_INFARCHCHECK
    SOLVER_FLAG_BEST_OBEY_POLICY = _solv.Solver_SOLVER_FLAG_BEST_OBEY_POLICY
    SOLVER_FLAG_NO_AUTOTARGET = _solv.Solver_SOLVER_FLAG_NO_AUTOTARGET
    SOLVER_FLAG_DUP_ALLOW_DOWNGRADE = _solv.Solver_SOLVER_FLAG_DUP_ALLOW_DOWNGRADE
    SOLVER_FLAG_DUP_ALLOW_ARCHCHANGE = _solv.Solver_SOLVER_FLAG_DUP_ALLOW_ARCHCHANGE
    SOLVER_FLAG_DUP_ALLOW_VENDORCHANGE = _solv.Solver_SOLVER_FLAG_DUP_ALLOW_VENDORCHANGE
    SOLVER_FLAG_DUP_ALLOW_NAMECHANGE = _solv.Solver_SOLVER_FLAG_DUP_ALLOW_NAMECHANGE
    SOLVER_FLAG_KEEP_ORPHANS = _solv.Solver_SOLVER_FLAG_KEEP_ORPHANS
    SOLVER_FLAG_BREAK_ORPHANS = _solv.Solver_SOLVER_FLAG_BREAK_ORPHANS
    SOLVER_FLAG_FOCUS_INSTALLED = _solv.Solver_SOLVER_FLAG_FOCUS_INSTALLED
    SOLVER_FLAG_YUM_OBSOLETES = _solv.Solver_SOLVER_FLAG_YUM_OBSOLETES
    SOLVER_FLAG_NEED_UPDATEPROVIDE = _solv.Solver_SOLVER_FLAG_NEED_UPDATEPROVIDE
    SOLVER_FLAG_FOCUS_BEST = _solv.Solver_SOLVER_FLAG_FOCUS_BEST
    SOLVER_FLAG_STRONG_RECOMMENDS = _solv.Solver_SOLVER_FLAG_STRONG_RECOMMENDS
    SOLVER_FLAG_INSTALL_ALSO_UPDATES = _solv.Solver_SOLVER_FLAG_INSTALL_ALSO_UPDATES
    SOLVER_REASON_UNRELATED = _solv.Solver_SOLVER_REASON_UNRELATED
    SOLVER_REASON_UNIT_RULE = _solv.Solver_SOLVER_REASON_UNIT_RULE
    SOLVER_REASON_KEEP_INSTALLED = _solv.Solver_SOLVER_REASON_KEEP_INSTALLED
    SOLVER_REASON_RESOLVE_JOB = _solv.Solver_SOLVER_REASON_RESOLVE_JOB
    SOLVER_REASON_UPDATE_INSTALLED = _solv.Solver_SOLVER_REASON_UPDATE_INSTALLED
    SOLVER_REASON_CLEANDEPS_ERASE = _solv.Solver_SOLVER_REASON_CLEANDEPS_ERASE
    SOLVER_REASON_RESOLVE = _solv.Solver_SOLVER_REASON_RESOLVE
    SOLVER_REASON_WEAKDEP = _solv.Solver_SOLVER_REASON_WEAKDEP
    SOLVER_REASON_RESOLVE_ORPHAN = _solv.Solver_SOLVER_REASON_RESOLVE_ORPHAN
    SOLVER_REASON_RECOMMENDED = _solv.Solver_SOLVER_REASON_RECOMMENDED
    SOLVER_REASON_SUPPLEMENTED = _solv.Solver_SOLVER_REASON_SUPPLEMENTED
    SOLVER_RULE_RPM = _solv.Solver_SOLVER_RULE_RPM
    __swig_destroy__ = _solv.delete_Solver
    __del__ = lambda self: None

    def set_flag(self, flag, value):
        return _solv.Solver_set_flag(self, flag, value)

    def get_flag(self, flag):
        return _solv.Solver_get_flag(self, flag)

    def solve(self, jobs):
      j = []
      for job in jobs: j += [job.how, job.what]
      return self.solve_helper(j)


    def solve_helper(self, jobs):
        return _solv.Solver_solve_helper(self, jobs)

    def transaction(self):
        return _solv.Solver_transaction(self)

    def describe_decision(self, s):
        return _solv.Solver_describe_decision(self, s)

    def describe_weakdep_decision_raw(self, s):
        return _solv.Solver_describe_weakdep_decision_raw(self, s)

    def describe_weakdep_decision(self, s):
      d = iter(self.describe_weakdep_decision_raw(s))
      return [ (t, XSolvable(self.pool, sid), Dep(self.pool, id)) for t, sid, id in zip(d, d, d) ]


    def alternatives_count(self):
        return _solv.Solver_alternatives_count(self)

    def alternative(self, aid):
        return _solv.Solver_alternative(self, aid)

    def all_alternatives(self):
        return _solv.Solver_all_alternatives(self)

    def write_testcase(self, dir):
        return _solv.Solver_write_testcase(self, dir)

    def raw_decisions(self, filter=0):
        return _solv.Solver_raw_decisions(self, filter)

    def get_recommended(self, noselected=False):
        return _solv.Solver_get_recommended(self, noselected)

    def get_suggested(self, noselected=False):
        return _solv.Solver_get_suggested(self, noselected)
Solver_swigregister = _solv.Solver_swigregister
Solver_swigregister(Solver)

class Chksum(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Chksum, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Chksum, name)

    def __init__(self, *args):
        this = _solv.new_Chksum(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    if _newclass:
        from_bin = staticmethod(_solv.Chksum_from_bin)
    else:
        from_bin = _solv.Chksum_from_bin
    __swig_destroy__ = _solv.delete_Chksum
    __del__ = lambda self: None
    __swig_getmethods__["type"] = _solv.Chksum_type_get
    if _newclass:
        type = _swig_property(_solv.Chksum_type_get)

    def add(self, str):
        return _solv.Chksum_add(self, str)

    def add_fp(self, fp):
        return _solv.Chksum_add_fp(self, fp)

    def add_fd(self, fd):
        return _solv.Chksum_add_fd(self, fd)

    def add_stat(self, filename):
        return _solv.Chksum_add_stat(self, filename)

    def add_fstat(self, fd):
        return _solv.Chksum_add_fstat(self, fd)

    def raw(self):
        return _solv.Chksum_raw(self)

    def hex(self):
        return _solv.Chksum_hex(self)

    def typestr(self):
        return _solv.Chksum_typestr(self)

    def __eq__(self, chk):
        return _solv.Chksum___eq__(self, chk)

    def __ne__(self, chk):
        return _solv.Chksum___ne__(self, chk)

    def __str__(self):
        return _solv.Chksum___str__(self)

    def __repr__(self):
        return _solv.Chksum___repr__(self)
Chksum_swigregister = _solv.Chksum_swigregister
Chksum_swigregister(Chksum)

def Chksum_from_bin(type, str):
    return _solv.Chksum_from_bin(type, str)
Chksum_from_bin = _solv.Chksum_from_bin

class Solvsig(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Solvsig, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Solvsig, name)
    __repr__ = _swig_repr
    __swig_getmethods__["htype"] = _solv.Solvsig_htype_get
    if _newclass:
        htype = _swig_property(_solv.Solvsig_htype_get)
    __swig_getmethods__["created"] = _solv.Solvsig_created_get
    if _newclass:
        created = _swig_property(_solv.Solvsig_created_get)
    __swig_getmethods__["expires"] = _solv.Solvsig_expires_get
    if _newclass:
        expires = _swig_property(_solv.Solvsig_expires_get)
    __swig_getmethods__["keyid"] = _solv.Solvsig_keyid_get
    if _newclass:
        keyid = _swig_property(_solv.Solvsig_keyid_get)

    def __init__(self, fp):
        this = _solv.new_Solvsig(fp)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _solv.delete_Solvsig
    __del__ = lambda self: None

    def Chksum(self):
        return _solv.Solvsig_Chksum(self)

    def verify(self, repo, chksum):
        return _solv.Solvsig_verify(self, repo, chksum)
Solvsig_swigregister = _solv.Solvsig_swigregister
Solvsig_swigregister(Solvsig)

class SolvFp(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SolvFp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SolvFp, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _solv.delete_SolvFp
    __del__ = lambda self: None

    def fileno(self):
        return _solv.SolvFp_fileno(self)

    def dup(self):
        return _solv.SolvFp_dup(self)

    def write(self, str):
        return _solv.SolvFp_write(self, str)

    def flush(self):
        return _solv.SolvFp_flush(self)

    def close(self):
        return _solv.SolvFp_close(self)

    def cloexec(self, state):
        return _solv.SolvFp_cloexec(self, state)
SolvFp_swigregister = _solv.SolvFp_swigregister
SolvFp_swigregister(SolvFp)


def xfopen(fn, mode=None):
    return _solv.xfopen(fn, mode)
xfopen = _solv.xfopen

def xfopen_fd(fn, fd, mode=None):
    return _solv.xfopen_fd(fn, fd, mode)
xfopen_fd = _solv.xfopen_fd
class Problem(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Problem, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Problem, name)
    __repr__ = _swig_repr
    __swig_getmethods__["solv"] = _solv.Problem_solv_get
    if _newclass:
        solv = _swig_property(_solv.Problem_solv_get)
    __swig_getmethods__["id"] = _solv.Problem_id_get
    if _newclass:
        id = _swig_property(_solv.Problem_id_get)

    def __init__(self, solv, id):
        this = _solv.new_Problem(solv, id)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def findproblemrule(self):
        return _solv.Problem_findproblemrule(self)

    def findallproblemrules(self, unfiltered=0):
        return _solv.Problem_findallproblemrules(self, unfiltered)

    def solution_count(self):
        return _solv.Problem_solution_count(self)

    def solutions(self):
        return _solv.Problem_solutions(self)

    def __str__(self):
        return _solv.Problem___str__(self)
    __swig_destroy__ = _solv.delete_Problem
    __del__ = lambda self: None
Problem_swigregister = _solv.Problem_swigregister
Problem_swigregister(Problem)

class Solution(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Solution, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Solution, name)
    __repr__ = _swig_repr
    __swig_getmethods__["solv"] = _solv.Solution_solv_get
    if _newclass:
        solv = _swig_property(_solv.Solution_solv_get)
    __swig_getmethods__["problemid"] = _solv.Solution_problemid_get
    if _newclass:
        problemid = _swig_property(_solv.Solution_problemid_get)
    __swig_getmethods__["id"] = _solv.Solution_id_get
    if _newclass:
        id = _swig_property(_solv.Solution_id_get)

    def __init__(self, p, id):
        this = _solv.new_Solution(p, id)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def element_count(self):
        return _solv.Solution_element_count(self)

    def elements(self, expandreplaces=False):
        return _solv.Solution_elements(self, expandreplaces)
    __swig_destroy__ = _solv.delete_Solution
    __del__ = lambda self: None
Solution_swigregister = _solv.Solution_swigregister
Solution_swigregister(Solution)

class Solutionelement(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Solutionelement, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Solutionelement, name)
    __repr__ = _swig_repr
    __swig_getmethods__["solv"] = _solv.Solutionelement_solv_get
    if _newclass:
        solv = _swig_property(_solv.Solutionelement_solv_get)
    __swig_getmethods__["problemid"] = _solv.Solutionelement_problemid_get
    if _newclass:
        problemid = _swig_property(_solv.Solutionelement_problemid_get)
    __swig_getmethods__["solutionid"] = _solv.Solutionelement_solutionid_get
    if _newclass:
        solutionid = _swig_property(_solv.Solutionelement_solutionid_get)
    __swig_getmethods__["id"] = _solv.Solutionelement_id_get
    if _newclass:
        id = _swig_property(_solv.Solutionelement_id_get)
    __swig_getmethods__["type"] = _solv.Solutionelement_type_get
    if _newclass:
        type = _swig_property(_solv.Solutionelement_type_get)

    def __init__(self, solv, problemid, solutionid, id, type, p, rp):
        this = _solv.new_Solutionelement(solv, problemid, solutionid, id, type, p, rp)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def str(self):
        return _solv.Solutionelement_str(self)

    def replaceelements(self):
        return _solv.Solutionelement_replaceelements(self)

    def illegalreplace(self):
        return _solv.Solutionelement_illegalreplace(self)
    __swig_getmethods__["solvable"] = _solv.Solutionelement_solvable_get
    if _newclass:
        solvable = _swig_property(_solv.Solutionelement_solvable_get)
    __swig_getmethods__["replacement"] = _solv.Solutionelement_replacement_get
    if _newclass:
        replacement = _swig_property(_solv.Solutionelement_replacement_get)
    __swig_getmethods__["jobidx"] = _solv.Solutionelement_jobidx_get
    if _newclass:
        jobidx = _swig_property(_solv.Solutionelement_jobidx_get)

    def Job(self):
        return _solv.Solutionelement_Job(self)
    __swig_destroy__ = _solv.delete_Solutionelement
    __del__ = lambda self: None
Solutionelement_swigregister = _solv.Solutionelement_swigregister
Solutionelement_swigregister(Solutionelement)

class Alternative(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Alternative, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Alternative, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_getmethods__["solv"] = _solv.Alternative_solv_get
    if _newclass:
        solv = _swig_property(_solv.Alternative_solv_get)
    __swig_getmethods__["type"] = _solv.Alternative_type_get
    if _newclass:
        type = _swig_property(_solv.Alternative_type_get)
    __swig_getmethods__["rid"] = _solv.Alternative_rid_get
    if _newclass:
        rid = _swig_property(_solv.Alternative_rid_get)
    __swig_getmethods__["from_id"] = _solv.Alternative_from_id_get
    if _newclass:
        from_id = _swig_property(_solv.Alternative_from_id_get)
    __swig_getmethods__["dep_id"] = _solv.Alternative_dep_id_get
    if _newclass:
        dep_id = _swig_property(_solv.Alternative_dep_id_get)
    __swig_getmethods__["chosen_id"] = _solv.Alternative_chosen_id_get
    if _newclass:
        chosen_id = _swig_property(_solv.Alternative_chosen_id_get)
    __swig_setmethods__["level"] = _solv.Alternative_level_set
    __swig_getmethods__["level"] = _solv.Alternative_level_get
    if _newclass:
        level = _swig_property(_solv.Alternative_level_get, _solv.Alternative_level_set)
    SOLVER_ALTERNATIVE_TYPE_RULE = _solv.Alternative_SOLVER_ALTERNATIVE_TYPE_RULE
    SOLVER_ALTERNATIVE_TYPE_RECOMMENDS = _solv.Alternative_SOLVER_ALTERNATIVE_TYPE_RECOMMENDS
    SOLVER_ALTERNATIVE_TYPE_SUGGESTS = _solv.Alternative_SOLVER_ALTERNATIVE_TYPE_SUGGESTS
    __swig_destroy__ = _solv.delete_Alternative
    __del__ = lambda self: None
    __swig_getmethods__["chosen"] = _solv.Alternative_chosen_get
    if _newclass:
        chosen = _swig_property(_solv.Alternative_chosen_get)
    __swig_getmethods__["rule"] = _solv.Alternative_rule_get
    if _newclass:
        rule = _swig_property(_solv.Alternative_rule_get)
    __swig_getmethods__["depsolvable"] = _solv.Alternative_depsolvable_get
    if _newclass:
        depsolvable = _swig_property(_solv.Alternative_depsolvable_get)
    __swig_getmethods__["dep"] = _solv.Alternative_dep_get
    if _newclass:
        dep = _swig_property(_solv.Alternative_dep_get)

    def choices_raw(self):
        return _solv.Alternative_choices_raw(self)

    def choices(self):
        return _solv.Alternative_choices(self)

    def __str__(self):
        return _solv.Alternative___str__(self)
Alternative_swigregister = _solv.Alternative_swigregister
Alternative_swigregister(Alternative)

class Transaction(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Transaction, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Transaction, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_getmethods__["pool"] = _solv.Transaction_pool_get
    if _newclass:
        pool = _swig_property(_solv.Transaction_pool_get)
    SOLVER_TRANSACTION_IGNORE = _solv.Transaction_SOLVER_TRANSACTION_IGNORE
    SOLVER_TRANSACTION_ERASE = _solv.Transaction_SOLVER_TRANSACTION_ERASE
    SOLVER_TRANSACTION_REINSTALLED = _solv.Transaction_SOLVER_TRANSACTION_REINSTALLED
    SOLVER_TRANSACTION_DOWNGRADED = _solv.Transaction_SOLVER_TRANSACTION_DOWNGRADED
    SOLVER_TRANSACTION_CHANGED = _solv.Transaction_SOLVER_TRANSACTION_CHANGED
    SOLVER_TRANSACTION_UPGRADED = _solv.Transaction_SOLVER_TRANSACTION_UPGRADED
    SOLVER_TRANSACTION_OBSOLETED = _solv.Transaction_SOLVER_TRANSACTION_OBSOLETED
    SOLVER_TRANSACTION_INSTALL = _solv.Transaction_SOLVER_TRANSACTION_INSTALL
    SOLVER_TRANSACTION_REINSTALL = _solv.Transaction_SOLVER_TRANSACTION_REINSTALL
    SOLVER_TRANSACTION_DOWNGRADE = _solv.Transaction_SOLVER_TRANSACTION_DOWNGRADE
    SOLVER_TRANSACTION_CHANGE = _solv.Transaction_SOLVER_TRANSACTION_CHANGE
    SOLVER_TRANSACTION_UPGRADE = _solv.Transaction_SOLVER_TRANSACTION_UPGRADE
    SOLVER_TRANSACTION_OBSOLETES = _solv.Transaction_SOLVER_TRANSACTION_OBSOLETES
    SOLVER_TRANSACTION_MULTIINSTALL = _solv.Transaction_SOLVER_TRANSACTION_MULTIINSTALL
    SOLVER_TRANSACTION_MULTIREINSTALL = _solv.Transaction_SOLVER_TRANSACTION_MULTIREINSTALL
    SOLVER_TRANSACTION_MAXTYPE = _solv.Transaction_SOLVER_TRANSACTION_MAXTYPE
    SOLVER_TRANSACTION_SHOW_ACTIVE = _solv.Transaction_SOLVER_TRANSACTION_SHOW_ACTIVE
    SOLVER_TRANSACTION_SHOW_ALL = _solv.Transaction_SOLVER_TRANSACTION_SHOW_ALL
    SOLVER_TRANSACTION_SHOW_OBSOLETES = _solv.Transaction_SOLVER_TRANSACTION_SHOW_OBSOLETES
    SOLVER_TRANSACTION_SHOW_MULTIINSTALL = _solv.Transaction_SOLVER_TRANSACTION_SHOW_MULTIINSTALL
    SOLVER_TRANSACTION_CHANGE_IS_REINSTALL = _solv.Transaction_SOLVER_TRANSACTION_CHANGE_IS_REINSTALL
    SOLVER_TRANSACTION_OBSOLETE_IS_UPGRADE = _solv.Transaction_SOLVER_TRANSACTION_OBSOLETE_IS_UPGRADE
    SOLVER_TRANSACTION_MERGE_VENDORCHANGES = _solv.Transaction_SOLVER_TRANSACTION_MERGE_VENDORCHANGES
    SOLVER_TRANSACTION_MERGE_ARCHCHANGES = _solv.Transaction_SOLVER_TRANSACTION_MERGE_ARCHCHANGES
    SOLVER_TRANSACTION_RPM_ONLY = _solv.Transaction_SOLVER_TRANSACTION_RPM_ONLY
    SOLVER_TRANSACTION_ARCHCHANGE = _solv.Transaction_SOLVER_TRANSACTION_ARCHCHANGE
    SOLVER_TRANSACTION_VENDORCHANGE = _solv.Transaction_SOLVER_TRANSACTION_VENDORCHANGE
    SOLVER_TRANSACTION_KEEP_ORDERDATA = _solv.Transaction_SOLVER_TRANSACTION_KEEP_ORDERDATA
    __swig_destroy__ = _solv.delete_Transaction
    __del__ = lambda self: None

    def isempty(self):
        return _solv.Transaction_isempty(self)

    def othersolvable(self, s):
        return _solv.Transaction_othersolvable(self, s)

    def allothersolvables(self, s):
        return _solv.Transaction_allothersolvables(self, s)

    def classify(self, mode=0):
        return _solv.Transaction_classify(self, mode)

    def newpackages(self):
        return _solv.Transaction_newpackages(self)

    def keptpackages(self):
        return _solv.Transaction_keptpackages(self)

    def newsolvables(self):
        return _solv.Transaction_newsolvables(self)

    def keptsolvables(self):
        return _solv.Transaction_keptsolvables(self)

    def steps(self):
        return _solv.Transaction_steps(self)

    def steptype(self, s, mode):
        return _solv.Transaction_steptype(self, s, mode)

    def calc_installsizechange(self):
        return _solv.Transaction_calc_installsizechange(self)

    def order(self, flags=0):
        return _solv.Transaction_order(self, flags)
Transaction_swigregister = _solv.Transaction_swigregister
Transaction_swigregister(Transaction)

class TransactionClass(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TransactionClass, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TransactionClass, name)
    __repr__ = _swig_repr
    __swig_getmethods__["transaction"] = _solv.TransactionClass_transaction_get
    if _newclass:
        transaction = _swig_property(_solv.TransactionClass_transaction_get)
    __swig_getmethods__["type"] = _solv.TransactionClass_type_get
    if _newclass:
        type = _swig_property(_solv.TransactionClass_type_get)
    __swig_getmethods__["fromid"] = _solv.TransactionClass_fromid_get
    if _newclass:
        fromid = _swig_property(_solv.TransactionClass_fromid_get)
    __swig_getmethods__["toid"] = _solv.TransactionClass_toid_get
    if _newclass:
        toid = _swig_property(_solv.TransactionClass_toid_get)
    __swig_getmethods__["count"] = _solv.TransactionClass_count_get
    if _newclass:
        count = _swig_property(_solv.TransactionClass_count_get)

    def __init__(self, trans, mode, type, count, fromid, toid):
        this = _solv.new_TransactionClass(trans, mode, type, count, fromid, toid)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def solvables(self):
        return _solv.TransactionClass_solvables(self)
    __swig_getmethods__["fromstr"] = _solv.TransactionClass_fromstr_get
    if _newclass:
        fromstr = _swig_property(_solv.TransactionClass_fromstr_get)
    __swig_getmethods__["tostr"] = _solv.TransactionClass_tostr_get
    if _newclass:
        tostr = _swig_property(_solv.TransactionClass_tostr_get)
    __swig_destroy__ = _solv.delete_TransactionClass
    __del__ = lambda self: None
TransactionClass_swigregister = _solv.TransactionClass_swigregister
TransactionClass_swigregister(TransactionClass)

# This file is compatible with both classic and new-style classes.