ACC SHELL

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.40
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.
# This file is compatible with both classic and new-style classes.

from sys import version_info
if 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('_satsolver', [dirname(__file__)])
        except ImportError:
            import _satsolver
            return _satsolver
        if fp is not None:
            try:
                _mod = imp.load_module('_satsolver', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _satsolver = swig_import_helper()
    del swig_import_helper
else:
    import _satsolver
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
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) or hasattr(self,name):
        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(name)

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

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


class Pool(_object):
    """Proxy of C Pool struct"""
    __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
    def __init__(self, arch = None): 
        """__init__(self, char arch = None) -> Pool"""
        this = _satsolver.new_Pool(arch)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _satsolver.delete_Pool
    __del__ = lambda self : None;
    def discard(self):
        """discard(self)"""
        return _satsolver.Pool_discard(self)

    def solvable(self, *args):
        """solvable(self, int id) -> XSolvable"""
        return _satsolver.Pool_solvable(self, *args)

    def relation(self, *args):
        """relation(self, int rel)"""
        return _satsolver.Pool_relation(self, *args)

    def set_arch(self, *args):
        """set_arch(self, char arch)"""
        return _satsolver.Pool_set_arch(self, *args)

    def set_debug(self, *args):
        """Makes the stuff noisy on stderr."""
        return _satsolver.Pool_set_debug(self, *args)

    def promoteepoch(self):
        """promoteepoch(self) -> int"""
        return _satsolver.Pool_promoteepoch(self)

    def set_promoteepoch(self, *args):
        """set_promoteepoch(self, int b)"""
        return _satsolver.Pool_set_promoteepoch(self, *args)

    def no_virtual_conflicts(self):
        """no_virtual_conflicts(self) -> int"""
        return _satsolver.Pool_no_virtual_conflicts(self)

    def set_no_virtual_conflicts(self, *args):
        """set_no_virtual_conflicts(self, int bflag)"""
        return _satsolver.Pool_set_no_virtual_conflicts(self, *args)

    def allow_self_conflicts(self):
        """allow_self_conflicts(self) -> int"""
        return _satsolver.Pool_allow_self_conflicts(self)

    def set_allow_self_conflicts(self, *args):
        """set_allow_self_conflicts(self, int bflag)"""
        return _satsolver.Pool_set_allow_self_conflicts(self, *args)

    def obsolete_uses_provides(self):
        """obsolete_uses_provides(self) -> int"""
        return _satsolver.Pool_obsolete_uses_provides(self)

    def set_obsolete_uses_provides(self, *args):
        """set_obsolete_uses_provides(self, int bflag)"""
        return _satsolver.Pool_set_obsolete_uses_provides(self, *args)

    def implicit_obsolete_uses_provides(self):
        """implicit_obsolete_uses_provides(self) -> int"""
        return _satsolver.Pool_implicit_obsolete_uses_provides(self)

    def set_implicit_obsolete_uses_provides(self, *args):
        """set_implicit_obsolete_uses_provides(self, int bflag)"""
        return _satsolver.Pool_set_implicit_obsolete_uses_provides(self, *args)

    def unprepared(self):
        """unprepared(self) -> int"""
        return _satsolver.Pool_unprepared(self)

    def prepare(self):
        """prepare(self)"""
        return _satsolver.Pool_prepare(self)

    def system(self):
        """system(self) -> XSolvable"""
        return _satsolver.Pool_system(self)

    def __ne__(self, *args):
        """__ne__(self,  pool) -> int"""
        return _satsolver.Pool___ne__(self, *args)

    def __eq__(self, *args):
        """__eq__(self,  pool) -> int"""
        return _satsolver.Pool___eq__(self, *args)

    def add_file(self, *args):
        """add_file(self, FILE fp)"""
        return _satsolver.Pool_add_file(self, *args)

    def add_solv(self, *args):
        """add_solv(self, char fname)"""
        return _satsolver.Pool_add_solv(self, *args)

    def add_rpmdb(self, *args):
        """add_rpmdb(self, char rootdir)"""
        return _satsolver.Pool_add_rpmdb(self, *args)

    def create_repo(self, name = None):
        """create_repo(self, char name = None)"""
        return _satsolver.Pool_create_repo(self, name)

    def count_repos(self):
        """count_repos(self) -> int"""
        return _satsolver.Pool_count_repos(self)

    def get_repo(self, *args):
        """get_repo(self, int i)"""
        return _satsolver.Pool_get_repo(self, *args)

    def repos(self):
      r = range(0,self.count_repos())
      while r:
        yield self.get_repo(r.pop(0))

    def find_repo(self, *args):
        """find_repo(self, char name)"""
        return _satsolver.Pool_find_repo(self, *args)

    def create_relation(self, *args):
        """create_relation(self, char name, int op = 0, char evr = None)"""
        return _satsolver.Pool_create_relation(self, *args)

    def providers_count(self, *args):
        """
        providers_count(self, char name) -> int
        providers_count(self,  rel) -> int
        """
        return _satsolver.Pool_providers_count(self, *args)

    def providers_get(self, *args):
        """
        providers_get(self, char name, int i) -> XSolvable
        providers_get(self,  rel, int i) -> XSolvable
        """
        return _satsolver.Pool_providers_get(self, *args)

    def providers(self,what):
      if self.unprepared():
        self.prepare()
      r = range(0,self.providers_count(what))
      while r:
        yield self.providers_get(what, r.pop(0))

    def size(self):
        """size(self) -> int"""
        return _satsolver.Pool_size(self)

    def installable(self, *args):
        """installable(self, XSolvable s) -> int"""
        return _satsolver.Pool_installable(self, *args)

    def count(self):
        """count(self) -> int"""
        return _satsolver.Pool_count(self)

    def solvables(self):
        """solvables(self) -> XSolvable"""
        return _satsolver.Pool_solvables(self)

    def __iter__(self):
      s = self.solvables()
      while s:
        yield s.pop(0)

    def find(self, *args):
        """find(self, char name,  repo = None) -> XSolvable"""
        return _satsolver.Pool_find(self, *args)

    def search(self, match, flags, solvable = None, keyname = None):
      d = Dataiterator(self, None, match, flags, solvable, keyname)
      while d.step():
        yield d

    def create_request(self):
        """create_request(self)"""
        return _satsolver.Pool_create_request(self)

    def set_installed(self, installed = None):
        """set_installed(self,  installed = None)"""
        return _satsolver.Pool_set_installed(self, installed)

    def installed(self):
        """installed(self)"""
        return _satsolver.Pool_installed(self)

    def create_solver(self):
        """create_solver(self)"""
        return _satsolver.Pool_create_solver(self)

Pool_swigregister = _satsolver.Pool_swigregister
Pool_swigregister(Pool)

class Repo(_object):
    """Proxy of C Repo struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Repo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Repo, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self,  pool, char reponame) -> Repo"""
        this = _satsolver.new_Repo(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _satsolver.delete_Repo
    __del__ = lambda self : None;
    def discard(self):
        """discard(self)"""
        return _satsolver.Repo_discard(self)

    def __str__(self):
        """__str__(self) -> char"""
        return _satsolver.Repo___str__(self)

    def size(self):
        """size(self) -> int"""
        return _satsolver.Repo_size(self)

    def empty(self):
        """empty(self) -> int"""
        return _satsolver.Repo_empty(self)

    def name(self):
        """name(self) -> char"""
        return _satsolver.Repo_name(self)

    def set_name(self, *args):
        """set_name(self, char name)"""
        return _satsolver.Repo_set_name(self, *args)

    def priority(self):
        """priority(self) -> int"""
        return _satsolver.Repo_priority(self)

    def set_priority(self, *args):
        """set_priority(self, int i)"""
        return _satsolver.Repo_set_priority(self, *args)

    def pool(self):
        """pool(self)"""
        return _satsolver.Repo_pool(self)

    def add_file(self, *args):
        """add_file(self, FILE fp)"""
        return _satsolver.Repo_add_file(self, *args)

    def add_solv(self, *args):
        """add_solv(self, char fname)"""
        return _satsolver.Repo_add_solv(self, *args)

    def add_rpmdb(self, *args):
        """add_rpmdb(self, char rootdir)"""
        return _satsolver.Repo_add_rpmdb(self, *args)

    def create_solvable(self, *args):
        """create_solvable(self, char name, char evr, char arch = None) -> XSolvable"""
        return _satsolver.Repo_create_solvable(self, *args)

    def add(self, *args):
        """add(self, XSolvable xs) -> XSolvable"""
        return _satsolver.Repo_add(self, *args)

    def count(self):
        """count(self) -> int"""
        return _satsolver.Repo_count(self)

    def solvables(self):
        """solvables(self) -> XSolvable"""
        return _satsolver.Repo_solvables(self)

    def __iter__(self):
      s = self.solvables()
      while s:
        yield s.pop(0)

    def find(self, *args):
        """find(self, char name) -> XSolvable"""
        return _satsolver.Repo_find(self, *args)

    def datasize(self):
        """datasize(self) -> int"""
        return _satsolver.Repo_datasize(self)

    def data(self, *args):
        """data(self, int i)"""
        return _satsolver.Repo_data(self, *args)

    def datas(self):
      r = range(0,self.datasize())
      while r:
        yield self.data(r.pop(0))

    def search(self, match, flags, solvable = None, keyname = None):
      d = Dataiterator(self.pool(), self, match, flags, solvable, keyname)
      while d.step():
        yield d

    def attr(self, *args):
        """attr(self, char name) -> PyObject"""
        return _satsolver.Repo_attr(self, *args)

Repo_swigregister = _satsolver.Repo_swigregister
Repo_swigregister(Repo)

class Repodata(_object):
    """Proxy of C Repodata struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Repodata, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Repodata, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def size(self):
        """size(self) -> int"""
        return _satsolver.Repodata_size(self)

    def key(self, *args):
        """key(self, int i) -> XRepokey"""
        return _satsolver.Repodata_key(self, *args)

    def keys(self):
      r = range(0,self.size())
      while r:
        yield self.key(r.pop(0))

Repodata_swigregister = _satsolver.Repodata_swigregister
Repodata_swigregister(Repodata)

class Repokey(_object):
    """Proxy of C XRepokey struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Repokey, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Repokey, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _satsolver.delete_Repokey
    __del__ = lambda self : None;
    def name(self):
        """name(self) -> char"""
        return _satsolver.Repokey_name(self)

    def type_id(self):
        """type_id(self) -> int"""
        return _satsolver.Repokey_type_id(self)

    def type(self):
        """type(self) -> PyTypeObject"""
        return _satsolver.Repokey_type(self)

    def size(self):
        """size(self) -> int"""
        return _satsolver.Repokey_size(self)

    def __str__(self):
        """__str__(self) -> char"""
        return _satsolver.Repokey___str__(self)

Repokey_swigregister = _satsolver.Repokey_swigregister
Repokey_swigregister(Repokey)
REPOKEY_TYPE_VOID = _satsolver.REPOKEY_TYPE_VOID
REPOKEY_TYPE_CONSTANT = _satsolver.REPOKEY_TYPE_CONSTANT
REPOKEY_TYPE_CONSTANTID = _satsolver.REPOKEY_TYPE_CONSTANTID
REPOKEY_TYPE_ID = _satsolver.REPOKEY_TYPE_ID
REPOKEY_TYPE_NUM = _satsolver.REPOKEY_TYPE_NUM
REPOKEY_TYPE_U32 = _satsolver.REPOKEY_TYPE_U32
REPOKEY_TYPE_DIR = _satsolver.REPOKEY_TYPE_DIR
REPOKEY_TYPE_STR = _satsolver.REPOKEY_TYPE_STR
REPOKEY_TYPE_IDARRAY = _satsolver.REPOKEY_TYPE_IDARRAY
REPOKEY_TYPE_REL_IDARRAY = _satsolver.REPOKEY_TYPE_REL_IDARRAY
REPOKEY_TYPE_DIRSTRARRAY = _satsolver.REPOKEY_TYPE_DIRSTRARRAY
REPOKEY_TYPE_DIRNUMNUMARRAY = _satsolver.REPOKEY_TYPE_DIRNUMNUMARRAY
REPOKEY_TYPE_MD5 = _satsolver.REPOKEY_TYPE_MD5
REPOKEY_TYPE_SHA1 = _satsolver.REPOKEY_TYPE_SHA1
REPOKEY_TYPE_SHA256 = _satsolver.REPOKEY_TYPE_SHA256
REPOKEY_TYPE_FIXARRAY = _satsolver.REPOKEY_TYPE_FIXARRAY
REPOKEY_TYPE_FLEXARRAY = _satsolver.REPOKEY_TYPE_FLEXARRAY

class Relation(_object):
    """Proxy of C Relation struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Relation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Relation, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self,  pool, char name, int op = 0, char evr = None) -> Relation"""
        this = _satsolver.new_Relation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _satsolver.delete_Relation
    __del__ = lambda self : None;
    def __str__(self):
        """__str__(self) -> char"""
        return _satsolver.Relation___str__(self)

    def pool(self):
        """pool(self)"""
        return _satsolver.Relation_pool(self)

    def name(self):
        """name(self) -> char"""
        return _satsolver.Relation_name(self)

    def evr(self):
        """evr(self) -> char"""
        return _satsolver.Relation_evr(self)

    def op(self):
        """op(self) -> int"""
        return _satsolver.Relation_op(self)

    def op_s(self):
        """op_s(self) -> char"""
        return _satsolver.Relation_op_s(self)

    def __cmp__(self, *args):
        """__cmp__(self,  r) -> int"""
        return _satsolver.Relation___cmp__(self, *args)

    def match(self, *args):
        """match(self,  r) -> int"""
        return _satsolver.Relation_match(self, *args)

    def equal(self, *args):
        """equal(self,  r) -> int"""
        return _satsolver.Relation_equal(self, *args)

Relation_swigregister = _satsolver.Relation_swigregister
Relation_swigregister(Relation)
REL_NONE = _satsolver.REL_NONE
REL_GT = _satsolver.REL_GT
REL_EQ = _satsolver.REL_EQ
REL_GE = _satsolver.REL_GE
REL_LT = _satsolver.REL_LT
REL_NE = _satsolver.REL_NE
REL_LE = _satsolver.REL_LE
REL_AND = _satsolver.REL_AND
REL_OR = _satsolver.REL_OR
REL_WITH = _satsolver.REL_WITH
REL_NAMESPACE = _satsolver.REL_NAMESPACE

class Dependency(_object):
    """Proxy of C Dependency struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Dependency, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Dependency, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, XSolvable xsolvable, int dep) -> Dependency"""
        this = _satsolver.new_Dependency(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _satsolver.delete_Dependency
    __del__ = lambda self : None;
    def solvable(self):
        """solvable(self) -> XSolvable"""
        return _satsolver.Dependency_solvable(self)

    def size(self):
        """size(self) -> int"""
        return _satsolver.Dependency_size(self)

    def empty(self):
        """empty(self) -> int"""
        return _satsolver.Dependency_empty(self)

    def add(self, *args):
        """add(self,  rel, int pre = 0)"""
        return _satsolver.Dependency_add(self, *args)

    def get(self, *args):
        """get(self, int i)"""
        return _satsolver.Dependency_get(self, *args)

    def __iter__(self):
      r = range(0,self.size())
      while r:
        yield self.get(r.pop(0))

Dependency_swigregister = _satsolver.Dependency_swigregister
Dependency_swigregister(Dependency)
DEP_PRV = _satsolver.DEP_PRV
DEP_REQ = _satsolver.DEP_REQ
DEP_CON = _satsolver.DEP_CON
DEP_OBS = _satsolver.DEP_OBS
DEP_REC = _satsolver.DEP_REC
DEP_SUG = _satsolver.DEP_SUG
DEP_SUP = _satsolver.DEP_SUP
DEP_ENH = _satsolver.DEP_ENH

class Solvable(_object):
    """Proxy of C XSolvable struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Solvable, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Solvable, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self,  repo, char name, char evr, char arch = None) -> Solvable"""
        this = _satsolver.new_Solvable(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _satsolver.delete_Solvable
    __del__ = lambda self : None;
    def repo(self):
        """repo(self)"""
        return _satsolver.Solvable_repo(self)

    def id(self):
        """id(self) -> int"""
        return _satsolver.Solvable_id(self)

    def pool(self):
        """pool(self)"""
        return _satsolver.Solvable_pool(self)

    def name(self):
        """name(self) -> char"""
        return _satsolver.Solvable_name(self)

    def arch(self):
        """arch(self) -> char"""
        return _satsolver.Solvable_arch(self)

    def evr(self):
        """evr(self) -> char"""
        return _satsolver.Solvable_evr(self)

    def vendor(self):
        """vendor(self) -> char"""
        return _satsolver.Solvable_vendor(self)

    def set_vendor(self, *args):
        """set_vendor(self, char vendor)"""
        return _satsolver.Solvable_set_vendor(self, *args)

    def location(self):
        """location(self) -> PyObject"""
        return _satsolver.Solvable_location(self)

    def __str__(self):
        """__str__(self) -> char"""
        return _satsolver.Solvable___str__(self)

    def equal(self, *args):
        """equal(self, XSolvable xs) -> int"""
        return _satsolver.Solvable_equal(self, *args)

    def __cmp__(self, *args):
        """__cmp__(self, XSolvable xs) -> int"""
        return _satsolver.Solvable___cmp__(self, *args)

    def identical(self, *args):
        """identical(self, XSolvable xs) -> int"""
        return _satsolver.Solvable_identical(self, *args)

    def provides(self):
        """provides(self)"""
        return _satsolver.Solvable_provides(self)

    def requires(self):
        """requires(self)"""
        return _satsolver.Solvable_requires(self)

    def conflicts(self):
        """conflicts(self)"""
        return _satsolver.Solvable_conflicts(self)

    def obsoletes(self):
        """obsoletes(self)"""
        return _satsolver.Solvable_obsoletes(self)

    def recommends(self):
        """recommends(self)"""
        return _satsolver.Solvable_recommends(self)

    def suggests(self):
        """suggests(self)"""
        return _satsolver.Solvable_suggests(self)

    def supplements(self):
        """supplements(self)"""
        return _satsolver.Solvable_supplements(self)

    def enhances(self):
        """enhances(self)"""
        return _satsolver.Solvable_enhances(self)

    def attr(self, *args):
        """attr(self, char name) -> PyObject"""
        return _satsolver.Solvable_attr(self, *args)

    def attrs(self):
      d = Dataiterator(self.repo().pool(),self.repo(),None,SEARCH_NO_STORAGE_SOLVABLE,self)
      while d.step():
        yield d.value()
    def attr_values(self,name):
      d = Dataiterator(self.repo().pool(),self.repo(),None,0,self,name)
      while d.step():
        yield d.value()

    def attr_exists(self, *args):
        """attr_exists(self, char name) -> PyObject"""
        return _satsolver.Solvable_attr_exists(self, *args)

Solvable_swigregister = _satsolver.Solvable_swigregister
Solvable_swigregister(Solvable)
KIND_PACKAGE = _satsolver.KIND_PACKAGE
KIND_PRODUCT = _satsolver.KIND_PRODUCT
KIND_PATCH = _satsolver.KIND_PATCH
KIND_SOURCE = _satsolver.KIND_SOURCE
KIND_PATTERN = _satsolver.KIND_PATTERN
KIND_NOSOURCE = _satsolver.KIND_NOSOURCE

class Job(_object):
    """Proxy of C Job struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Job, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Job, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _satsolver.delete_Job
    __del__ = lambda self : None;
    def cmd(self):
        """cmd(self) -> int"""
        return _satsolver.Job_cmd(self)

    def solvable(self):
        """solvable(self) -> XSolvable"""
        return _satsolver.Job_solvable(self)

    def name(self):
        """name(self) -> char"""
        return _satsolver.Job_name(self)

    def relation(self):
        """relation(self)"""
        return _satsolver.Job_relation(self)

    def __ne__(self, *args):
        """__ne__(self,  job) -> int"""
        return _satsolver.Job___ne__(self, *args)

    def __eq__(self, *args):
        """__eq__(self,  job) -> int"""
        return _satsolver.Job___eq__(self, *args)

Job_swigregister = _satsolver.Job_swigregister
Job_swigregister(Job)
INSTALL_SOLVABLE = _satsolver.INSTALL_SOLVABLE
UPDATE_SOLVABLE = _satsolver.UPDATE_SOLVABLE
REMOVE_SOLVABLE = _satsolver.REMOVE_SOLVABLE
WEAKEN_SOLVABLE = _satsolver.WEAKEN_SOLVABLE
LOCK_SOLVABLE = _satsolver.LOCK_SOLVABLE
INSTALL_SOLVABLE_NAME = _satsolver.INSTALL_SOLVABLE_NAME
UPDATE_SOLVABLE_NAME = _satsolver.UPDATE_SOLVABLE_NAME
REMOVE_SOLVABLE_NAME = _satsolver.REMOVE_SOLVABLE_NAME
WEAKEN_SOLVABLE_NAME = _satsolver.WEAKEN_SOLVABLE_NAME
LOCK_SOLVABLE_NAME = _satsolver.LOCK_SOLVABLE_NAME
INSTALL_SOLVABLE_PROVIDES = _satsolver.INSTALL_SOLVABLE_PROVIDES
UPDATE_SOLVABLE_PROVIDES = _satsolver.UPDATE_SOLVABLE_PROVIDES
REMOVE_SOLVABLE_PROVIDES = _satsolver.REMOVE_SOLVABLE_PROVIDES
WEAKEN_SOLVABLE_PROVIDES = _satsolver.WEAKEN_SOLVABLE_PROVIDES
LOCK_SOLVABLE_PROVIDES = _satsolver.LOCK_SOLVABLE_PROVIDES
INSTALL_ONE_OF = _satsolver.INSTALL_ONE_OF
UPDATE_ONE_OF = _satsolver.UPDATE_ONE_OF
REMOVE_ONE_OF = _satsolver.REMOVE_ONE_OF
LOCK_ONE_OF = _satsolver.LOCK_ONE_OF

class Request(_object):
    """Proxy of C Request struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Request, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Request, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self,  pool) -> Request"""
        this = _satsolver.new_Request(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _satsolver.delete_Request
    __del__ = lambda self : None;
    def install(self, *args):
        """
        install(self, XSolvable xs)
        install(self, char name)
        install(self,  rel)
        """
        return _satsolver.Request_install(self, *args)

    def remove(self, *args):
        """
        remove(self, XSolvable xs)
        remove(self, char name)
        remove(self,  rel)
        """
        return _satsolver.Request_remove(self, *args)

    def update(self, *args):
        """
        update(self, XSolvable xs)
        update(self, char name)
        update(self,  rel)
        """
        return _satsolver.Request_update(self, *args)

    def lock(self, *args):
        """
        lock(self, XSolvable xs)
        lock(self, char name)
        lock(self,  rel)
        """
        return _satsolver.Request_lock(self, *args)

    def empty(self):
        """empty(self) -> int"""
        return _satsolver.Request_empty(self)

    def size(self):
        """size(self) -> int"""
        return _satsolver.Request_size(self)

    def clear(self):
        """clear(self)"""
        return _satsolver.Request_clear(self)

    def get(self, *args):
        """get(self, unsigned int i)"""
        return _satsolver.Request_get(self, *args)

    def each(self):
        """each(self)"""
        return _satsolver.Request_each(self)

Request_swigregister = _satsolver.Request_swigregister
Request_swigregister(Request)

class Decision(_object):
    """Proxy of C Decision struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Decision, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Decision, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _satsolver.delete_Decision
    __del__ = lambda self : None;
    def solver(self):
        """solver(self)"""
        return _satsolver.Decision_solver(self)

    def op(self):
        """op(self) -> int"""
        return _satsolver.Decision_op(self)

    def op_s(self):
        """op_s(self) -> char"""
        return _satsolver.Decision_op_s(self)

    def solvable(self):
        """solvable(self) -> XSolvable"""
        return _satsolver.Decision_solvable(self)

    def ruleinfo(self):
        """ruleinfo(self) -> PyObject"""
        return _satsolver.Decision_ruleinfo(self)

Decision_swigregister = _satsolver.Decision_swigregister
Decision_swigregister(Decision)
DECISION_INSTALL = _satsolver.DECISION_INSTALL
DECISION_REMOVE = _satsolver.DECISION_REMOVE
DECISION_UPDATE = _satsolver.DECISION_UPDATE
DECISION_OBSOLETE = _satsolver.DECISION_OBSOLETE
DECISION_WEAK = _satsolver.DECISION_WEAK
DECISION_FREE = _satsolver.DECISION_FREE

class Problem(_object):
    """Proxy of C Problem struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Problem, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Problem, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _satsolver.delete_Problem
    __del__ = lambda self : None;
    def solver(self):
        """solver(self)"""
        return _satsolver.Problem_solver(self)

    def each_ruleinfo(self):
        """each_ruleinfo(self)"""
        return _satsolver.Problem_each_ruleinfo(self)

    def solutions_count(self):
        """solutions_count(self) -> int"""
        return _satsolver.Problem_solutions_count(self)

    def each_solution(self):
        """each_solution(self)"""
        return _satsolver.Problem_each_solution(self)

Problem_swigregister = _satsolver.Problem_swigregister
Problem_swigregister(Problem)

class Solution(_object):
    """Proxy of C Solution struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Solution, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Solution, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _satsolver.delete_Solution
    __del__ = lambda self : None;
    def each_element(self):
        """each_element(self)"""
        return _satsolver.Solution_each_element(self)

Solution_swigregister = _satsolver.Solution_swigregister
Solution_swigregister(Solution)

class SolutionElement(_object):
    """Proxy of C SolutionElement struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SolutionElement, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SolutionElement, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _satsolver.delete_SolutionElement
    __del__ = lambda self : None;
    def cause(self):
        """cause(self) -> int"""
        return _satsolver.SolutionElement_cause(self)

    def job(self):
        """job(self)"""
        return _satsolver.SolutionElement_job(self)

SolutionElement_swigregister = _satsolver.SolutionElement_swigregister
SolutionElement_swigregister(SolutionElement)
SOLUTION_SOLVABLE = _satsolver.SOLUTION_SOLVABLE
SOLUTION_JOB = _satsolver.SOLUTION_JOB
SOLUTION_DISTUPGRADE = _satsolver.SOLUTION_DISTUPGRADE
SOLUTION_INFARCH = _satsolver.SOLUTION_INFARCH

class Covenant(_object):
    """Proxy of C Covenant struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Covenant, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Covenant, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _satsolver.delete_Covenant
    __del__ = lambda self : None;
    def cmd(self):
        """cmd(self) -> int"""
        return _satsolver.Covenant_cmd(self)

    def solvable(self):
        """solvable(self) -> XSolvable"""
        return _satsolver.Covenant_solvable(self)

    def name(self):
        """name(self) -> char"""
        return _satsolver.Covenant_name(self)

    def relation(self):
        """relation(self)"""
        return _satsolver.Covenant_relation(self)

Covenant_swigregister = _satsolver.Covenant_swigregister
Covenant_swigregister(Covenant)
INCLUDE_SOLVABLE = _satsolver.INCLUDE_SOLVABLE
EXCLUDE_SOLVABLE = _satsolver.EXCLUDE_SOLVABLE
INCLUDE_SOLVABLE_NAME = _satsolver.INCLUDE_SOLVABLE_NAME
EXCLUDE_SOLVABLE_NAME = _satsolver.EXCLUDE_SOLVABLE_NAME
INCLUDE_SOLVABLE_PROVIDES = _satsolver.INCLUDE_SOLVABLE_PROVIDES
EXCLUDE_SOLVABLE_PROVIDES = _satsolver.EXCLUDE_SOLVABLE_PROVIDES

class Ruleinfo(_object):
    """Proxy of C Ruleinfo struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Ruleinfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Ruleinfo, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def command(self):
        """command(self) -> int"""
        return _satsolver.Ruleinfo_command(self)

    def command_s(self):
        """command_s(self) -> char"""
        return _satsolver.Ruleinfo_command_s(self)

    def source(self):
        """source(self) -> XSolvable"""
        return _satsolver.Ruleinfo_source(self)

    def target(self):
        """target(self) -> XSolvable"""
        return _satsolver.Ruleinfo_target(self)

    def relation(self):
        """relation(self)"""
        return _satsolver.Ruleinfo_relation(self)

Ruleinfo_swigregister = _satsolver.Ruleinfo_swigregister
Ruleinfo_swigregister(Ruleinfo)
SOLVER_RULE_RPM = _satsolver.SOLVER_RULE_RPM
SOLVER_RULE_RPM_NOT_INSTALLABLE = _satsolver.SOLVER_RULE_RPM_NOT_INSTALLABLE
SOLVER_RULE_RPM_NOTHING_PROVIDES_DEP = _satsolver.SOLVER_RULE_RPM_NOTHING_PROVIDES_DEP
SOLVER_RULE_RPM_PACKAGE_REQUIRES = _satsolver.SOLVER_RULE_RPM_PACKAGE_REQUIRES
SOLVER_RULE_RPM_SELF_CONFLICT = _satsolver.SOLVER_RULE_RPM_SELF_CONFLICT
SOLVER_RULE_RPM_PACKAGE_CONFLICT = _satsolver.SOLVER_RULE_RPM_PACKAGE_CONFLICT
SOLVER_RULE_RPM_SAME_NAME = _satsolver.SOLVER_RULE_RPM_SAME_NAME
SOLVER_RULE_RPM_PACKAGE_OBSOLETES = _satsolver.SOLVER_RULE_RPM_PACKAGE_OBSOLETES
SOLVER_RULE_RPM_IMPLICIT_OBSOLETES = _satsolver.SOLVER_RULE_RPM_IMPLICIT_OBSOLETES
SOLVER_RULE_UPDATE = _satsolver.SOLVER_RULE_UPDATE
SOLVER_RULE_FEATURE = _satsolver.SOLVER_RULE_FEATURE
SOLVER_RULE_JOB = _satsolver.SOLVER_RULE_JOB
SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP = _satsolver.SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP
SOLVER_RULE_DISTUPGRADE = _satsolver.SOLVER_RULE_DISTUPGRADE
SOLVER_RULE_INFARCH = _satsolver.SOLVER_RULE_INFARCH
SOLVER_RULE_LEARNT = _satsolver.SOLVER_RULE_LEARNT

class Solver(_object):
    """Proxy of C Solver struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Solver, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Solver, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self,  pool) -> Solver"""
        this = _satsolver.new_Solver(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _satsolver.delete_Solver
    __del__ = lambda self : None;
    def pool(self):
        """pool(self)"""
        return _satsolver.Solver_pool(self)

    def fix_system(self):
        """fix_system(self) -> int"""
        return _satsolver.Solver_fix_system(self)

    def set_fix_system(self, *args):
        """set_fix_system(self, int bflag)"""
        return _satsolver.Solver_set_fix_system(self, *args)

    def allow_downgrade(self):
        """allow_downgrade(self) -> int"""
        return _satsolver.Solver_allow_downgrade(self)

    def set_allow_downgrade(self, *args):
        """set_allow_downgrade(self, int bflag)"""
        return _satsolver.Solver_set_allow_downgrade(self, *args)

    def allow_arch_change(self):
        """allow_arch_change(self) -> int"""
        return _satsolver.Solver_allow_arch_change(self)

    def set_allow_arch_change(self, *args):
        """set_allow_arch_change(self, int bflag)"""
        return _satsolver.Solver_set_allow_arch_change(self, *args)

    def allow_vendor_change(self):
        """allow_vendor_change(self) -> int"""
        return _satsolver.Solver_allow_vendor_change(self)

    def set_allow_vendor_change(self, *args):
        """set_allow_vendor_change(self, int bflag)"""
        return _satsolver.Solver_set_allow_vendor_change(self, *args)

    def allow_uninstall(self):
        """allow_uninstall(self) -> int"""
        return _satsolver.Solver_allow_uninstall(self)

    def set_allow_uninstall(self, *args):
        """set_allow_uninstall(self, int bflag)"""
        return _satsolver.Solver_set_allow_uninstall(self, *args)

    def update_system(self):
        """update_system(self) -> int"""
        return _satsolver.Solver_update_system(self)

    def set_update_system(self, *args):
        """set_update_system(self, int bflag)"""
        return _satsolver.Solver_set_update_system(self, *args)

    def no_update_provide(self):
        """no_update_provide(self) -> int"""
        return _satsolver.Solver_no_update_provide(self)

    def set_no_update_provide(self, *args):
        """set_no_update_provide(self, int bflag)"""
        return _satsolver.Solver_set_no_update_provide(self, *args)

    def do_split_provides(self):
        """do_split_provides(self) -> int"""
        return _satsolver.Solver_do_split_provides(self)

    def set_do_split_provides(self, *args):
        """set_do_split_provides(self, int bflag)"""
        return _satsolver.Solver_set_do_split_provides(self, *args)

    def dont_install_recommended(self):
        """dont_install_recommended(self) -> int"""
        return _satsolver.Solver_dont_install_recommended(self)

    def set_dont_install_recommended(self, *args):
        """set_dont_install_recommended(self, int bflag)"""
        return _satsolver.Solver_set_dont_install_recommended(self, *args)

    def ignore_already_recommended(self):
        """ignore_already_recommended(self) -> int"""
        return _satsolver.Solver_ignore_already_recommended(self)

    def set_ignore_already_recommended(self, *args):
        """set_ignore_already_recommended(self, int bflag)"""
        return _satsolver.Solver_set_ignore_already_recommended(self, *args)

    def dont_show_installed_recommended(self):
        """dont_show_installed_recommended(self) -> int"""
        return _satsolver.Solver_dont_show_installed_recommended(self)

    def set_dont_show_installed_recommended(self, *args):
        """set_dont_show_installed_recommended(self, int bflag)"""
        return _satsolver.Solver_set_dont_show_installed_recommended(self, *args)

    def distupgrade(self):
        """distupgrade(self) -> int"""
        return _satsolver.Solver_distupgrade(self)

    def set_distupgrade(self, *args):
        """set_distupgrade(self, int bflag)"""
        return _satsolver.Solver_set_distupgrade(self, *args)

    def distupgrade_remove_unsupported(self):
        """distupgrade_remove_unsupported(self) -> int"""
        return _satsolver.Solver_distupgrade_remove_unsupported(self)

    def set_distupgrade_remove_unsupported(self, *args):
        """set_distupgrade_remove_unsupported(self, int bflag)"""
        return _satsolver.Solver_set_distupgrade_remove_unsupported(self, *args)

    def rule_count(self):
        """rule_count(self) -> int"""
        return _satsolver.Solver_rule_count(self)

    def rpmrules_start(self):
        """rpmrules_start(self) -> int"""
        return _satsolver.Solver_rpmrules_start(self)

    def rpmrules_end(self):
        """rpmrules_end(self) -> int"""
        return _satsolver.Solver_rpmrules_end(self)

    def featurerules_start(self):
        """featurerules_start(self) -> int"""
        return _satsolver.Solver_featurerules_start(self)

    def featurerules_end(self):
        """featurerules_end(self) -> int"""
        return _satsolver.Solver_featurerules_end(self)

    def updaterules_start(self):
        """updaterules_start(self) -> int"""
        return _satsolver.Solver_updaterules_start(self)

    def updaterules_end(self):
        """updaterules_end(self) -> int"""
        return _satsolver.Solver_updaterules_end(self)

    def jobrules_start(self):
        """jobrules_start(self) -> int"""
        return _satsolver.Solver_jobrules_start(self)

    def jobrules_end(self):
        """jobrules_end(self) -> int"""
        return _satsolver.Solver_jobrules_end(self)

    def learntrules_start(self):
        """learntrules_start(self) -> int"""
        return _satsolver.Solver_learntrules_start(self)

    def learntrules_end(self):
        """learntrules_end(self) -> int"""
        return _satsolver.Solver_learntrules_end(self)

    def covenants_count(self):
        """covenants_count(self) -> int"""
        return _satsolver.Solver_covenants_count(self)

    def covenants_empty(self):
        """covenants_empty(self) -> int"""
        return _satsolver.Solver_covenants_empty(self)

    def covenants_clear(self):
        """covenants_clear(self)"""
        return _satsolver.Solver_covenants_clear(self)

    def include(self, *args):
        """
        include(self, XSolvable xs)
        include(self, char name)
        include(self,  rel)
        """
        return _satsolver.Solver_include(self, *args)

    def exclude(self, *args):
        """
        exclude(self, XSolvable xs)
        exclude(self, char name)
        exclude(self,  rel)
        """
        return _satsolver.Solver_exclude(self, *args)

    def get_covenant(self, *args):
        """get_covenant(self, unsigned int i)"""
        return _satsolver.Solver_get_covenant(self, *args)

    def solve(self, *args):
        """solve(self,  t) -> int"""
        return _satsolver.Solver_solve(self, *args)

    def transaction(self):
        """transaction(self)"""
        return _satsolver.Solver_transaction(self)

    def decision_count(self):
        """decision_count(self) -> int"""
        return _satsolver.Solver_decision_count(self)

    def sizechange(self):
        """sizechange(self) -> long"""
        return _satsolver.Solver_sizechange(self)

    def problems_found(self):
        """problems_found(self) -> int"""
        return _satsolver.Solver_problems_found(self)

    def problems_count(self):
        """problems_count(self) -> int"""
        return _satsolver.Solver_problems_count(self)

    def installs(self):
        """installs(self) -> XSolvable"""
        return _satsolver.Solver_installs(self)

    def updates(self):
        """updates(self) -> XSolvable"""
        return _satsolver.Solver_updates(self)

    def removes(self):
        """removes(self) -> XSolvable"""
        return _satsolver.Solver_removes(self)

Solver_swigregister = _satsolver.Solver_swigregister
Solver_swigregister(Solver)

class Dataiterator(_object):
    """Proxy of C Dataiterator struct"""
    __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
    def __init__(self, *args): 
        """
        __init__(self,  pool,  repo, char match, int option, XSolvable xs = None, 
            char keyname = None) -> Dataiterator
        """
        this = _satsolver.new_Dataiterator(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _satsolver.delete_Dataiterator
    __del__ = lambda self : None;
    def solvable(self):
        """solvable(self) -> XSolvable"""
        return _satsolver.Dataiterator_solvable(self)

    def key(self):
        """key(self) -> XRepokey"""
        return _satsolver.Dataiterator_key(self)

    def keyname(self):
        """keyname(self) -> char"""
        return _satsolver.Dataiterator_keyname(self)

    def value(self):
        """value(self) -> PyObject"""
        return _satsolver.Dataiterator_value(self)

    def step(self):
        """step(self) -> int"""
        return _satsolver.Dataiterator_step(self)

    def skip_attr(self):
        """skip_attr(self)"""
        return _satsolver.Dataiterator_skip_attr(self)

    def skip_solvable(self):
        """skip_solvable(self)"""
        return _satsolver.Dataiterator_skip_solvable(self)

    def skip_repo(self):
        """skip_repo(self)"""
        return _satsolver.Dataiterator_skip_repo(self)

    def jump_to_solvable(self, *args):
        """jump_to_solvable(self, XSolvable xs)"""
        return _satsolver.Dataiterator_jump_to_solvable(self, *args)

    def jump_to_repo(self, *args):
        """jump_to_repo(self,  repo)"""
        return _satsolver.Dataiterator_jump_to_repo(self, *args)

Dataiterator_swigregister = _satsolver.Dataiterator_swigregister
Dataiterator_swigregister(Dataiterator)
SEARCH_STRINGMASK = _satsolver.SEARCH_STRINGMASK
SEARCH_STRING = _satsolver.SEARCH_STRING
SEARCH_SUBSTRING = _satsolver.SEARCH_SUBSTRING
SEARCH_GLOB = _satsolver.SEARCH_GLOB
SEARCH_REGEX = _satsolver.SEARCH_REGEX
SEARCH_ERROR = _satsolver.SEARCH_ERROR
SEARCH_NOCASE = _satsolver.SEARCH_NOCASE
SEARCH_NO_STORAGE_SOLVABLE = _satsolver.SEARCH_NO_STORAGE_SOLVABLE
SEARCH_SUB = _satsolver.SEARCH_SUB
SEARCH_ARRAYSENTINEL = _satsolver.SEARCH_ARRAYSENTINEL
SEARCH_SKIP_KIND = _satsolver.SEARCH_SKIP_KIND
SEARCH_FILES = _satsolver.SEARCH_FILES

class Step(_object):
    """Proxy of C Step struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Step, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Step, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _satsolver.delete_Step
    __del__ = lambda self : None;
    def solvable(self):
        """solvable(self) -> XSolvable"""
        return _satsolver.Step_solvable(self)

    def type(self, *args):
        """type(self, int mode = SOLVER_TRANSACTION_RPM_ONLY) -> int"""
        return _satsolver.Step_type(self, *args)

    def type_s(self, *args):
        """type_s(self, int mode = SOLVER_TRANSACTION_RPM_ONLY) -> char"""
        return _satsolver.Step_type_s(self, *args)

    def __ne__(self, *args):
        """__ne__(self,  step) -> int"""
        return _satsolver.Step___ne__(self, *args)

    def __eq__(self, *args):
        """__eq__(self,  step) -> int"""
        return _satsolver.Step___eq__(self, *args)

Step_swigregister = _satsolver.Step_swigregister
Step_swigregister(Step)
STEP_IGNORE = _satsolver.STEP_IGNORE
STEP_ERASE = _satsolver.STEP_ERASE
STEP_REINSTALLED = _satsolver.STEP_REINSTALLED
STEP_DOWNGRADED = _satsolver.STEP_DOWNGRADED
STEP_CHANGED = _satsolver.STEP_CHANGED
STEP_UPGRADED = _satsolver.STEP_UPGRADED
STEP_OBSOLETED = _satsolver.STEP_OBSOLETED
STEP_INSTALL = _satsolver.STEP_INSTALL
STEP_REINSTALL = _satsolver.STEP_REINSTALL
STEP_DOWNGRADE = _satsolver.STEP_DOWNGRADE
STEP_CHANGE = _satsolver.STEP_CHANGE
STEP_UPGRADE = _satsolver.STEP_UPGRADE
STEP_OBSOLETES = _satsolver.STEP_OBSOLETES
STEP_MULTIINSTALL = _satsolver.STEP_MULTIINSTALL
STEP_MULTIREINSTALL = _satsolver.STEP_MULTIREINSTALL

class Transaction(_object):
    """Proxy of C Transaction struct"""
    __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_destroy__ = _satsolver.delete_Transaction
    __del__ = lambda self : None;
    def empty(self):
        """empty(self) -> int"""
        return _satsolver.Transaction_empty(self)

    def size(self):
        """size(self) -> int"""
        return _satsolver.Transaction_size(self)

    def sizechange(self):
        """sizechange(self) -> long"""
        return _satsolver.Transaction_sizechange(self)

    def order(self, flags = 0):
        """order(self, int flags = 0)"""
        return _satsolver.Transaction_order(self, flags)

    def get(self, *args):
        """get(self, unsigned int i)"""
        return _satsolver.Transaction_get(self, *args)

    def each(self):
        """each(self)"""
        return _satsolver.Transaction_each(self)

Transaction_swigregister = _satsolver.Transaction_swigregister
Transaction_swigregister(Transaction)
TRANSACTION_MODE_ACTIVE = _satsolver.TRANSACTION_MODE_ACTIVE
TRANSACTION_MODE_ALL = _satsolver.TRANSACTION_MODE_ALL
TRANSACTION_MODE_OBSOLETES = _satsolver.TRANSACTION_MODE_OBSOLETES
TRANSACTION_MODE_MULTIINSTALL = _satsolver.TRANSACTION_MODE_MULTIINSTALL
TRANSACTION_MODE_IS_REINSTALL = _satsolver.TRANSACTION_MODE_IS_REINSTALL
TRANSACTION_MODE_MERGE_VENDORCHANGES = _satsolver.TRANSACTION_MODE_MERGE_VENDORCHANGES
TRANSACTION_MODE_MERGE_ARCHCHANGES = _satsolver.TRANSACTION_MODE_MERGE_ARCHCHANGES
TRANSACTION_MODE_RPM_ONLY = _satsolver.TRANSACTION_MODE_RPM_ONLY
TRANSACTION_KEEP_ORDERDATA = _satsolver.TRANSACTION_KEEP_ORDERDATA