Sid Gifari File Manager Pro v10.0.3

✏️ Editing: transaction.py Read Only

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.12
#
# 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, '_transaction')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_transaction')
    _transaction = 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('_transaction', [dirname(__file__)])
        except ImportError:
            import _transaction
            return _transaction
        try:
            _mod = imp.load_module('_transaction', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _transaction = swig_import_helper()
    del swig_import_helper
else:
    import _transaction
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

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

def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _transaction.delete_SwigPyIterator
    __del__ = lambda self: None

def value(self):
        return _transaction.SwigPyIterator_value(self)

def incr(self, n=1):
        return _transaction.SwigPyIterator_incr(self, n)

def decr(self, n=1):
        return _transaction.SwigPyIterator_decr(self, n)

def distance(self, x):
        return _transaction.SwigPyIterator_distance(self, x)

def equal(self, x):
        return _transaction.SwigPyIterator_equal(self, x)

def copy(self):
        return _transaction.SwigPyIterator_copy(self)

def next(self):
        return _transaction.SwigPyIterator_next(self)

def __next__(self):
        return _transaction.SwigPyIterator___next__(self)

def previous(self):
        return _transaction.SwigPyIterator_previous(self)

def advance(self, n):
        return _transaction.SwigPyIterator_advance(self, n)

def __eq__(self, x):
        return _transaction.SwigPyIterator___eq__(self, x)

def __ne__(self, x):
        return _transaction.SwigPyIterator___ne__(self, x)

def __iadd__(self, n):
        return _transaction.SwigPyIterator___iadd__(self, n)

def __isub__(self, n):
        return _transaction.SwigPyIterator___isub__(self, n)

def __add__(self, n):
        return _transaction.SwigPyIterator___add__(self, n)

def __sub__(self, *args):
        return _transaction.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self
SwigPyIterator_swigregister = _transaction.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

SHARED_PTR_DISOWN = _transaction.SHARED_PTR_DISOWN
TransactionItemReason_UNKNOWN = _transaction.TransactionItemReason_UNKNOWN
TransactionItemReason_DEPENDENCY = _transaction.TransactionItemReason_DEPENDENCY
TransactionItemReason_USER = _transaction.TransactionItemReason_USER
TransactionItemReason_CLEAN = _transaction.TransactionItemReason_CLEAN
TransactionItemReason_WEAK_DEPENDENCY = _transaction.TransactionItemReason_WEAK_DEPENDENCY
TransactionItemReason_GROUP = _transaction.TransactionItemReason_GROUP

def TransactionItemReasonToString(reason):
    return _transaction.TransactionItemReasonToString(reason)
TransactionItemReasonToString = _transaction.TransactionItemReasonToString

def StringToTransactionItemReason(str):
    return _transaction.StringToTransactionItemReason(str)
StringToTransactionItemReason = _transaction.StringToTransactionItemReason

def __lt__(lhs, rhs):
    return _transaction.__lt__(lhs, rhs)
__lt__ = _transaction.__lt__

def __le__(lhs, rhs):
    return _transaction.__le__(lhs, rhs)
__le__ = _transaction.__le__

def __gt__(lhs, rhs):
    return _transaction.__gt__(lhs, rhs)
__gt__ = _transaction.__gt__

def __ge__(lhs, rhs):
    return _transaction.__ge__(lhs, rhs)
__ge__ = _transaction.__ge__

def TransactionItemReasonCompare(lhs, rhs):
    return _transaction.TransactionItemReasonCompare(lhs, rhs)
TransactionItemReasonCompare = _transaction.TransactionItemReasonCompare
TransactionState_UNKNOWN = _transaction.TransactionState_UNKNOWN
TransactionState_DONE = _transaction.TransactionState_DONE
TransactionState_ERROR = _transaction.TransactionState_ERROR
TransactionItemState_UNKNOWN = _transaction.TransactionItemState_UNKNOWN
TransactionItemState_DONE = _transaction.TransactionItemState_DONE
TransactionItemState_ERROR = _transaction.TransactionItemState_ERROR
ItemType_UNKNOWN = _transaction.ItemType_UNKNOWN
ItemType_RPM = _transaction.ItemType_RPM
ItemType_GROUP = _transaction.ItemType_GROUP
ItemType_ENVIRONMENT = _transaction.ItemType_ENVIRONMENT
TransactionItemAction_INSTALL = _transaction.TransactionItemAction_INSTALL
TransactionItemAction_DOWNGRADE = _transaction.TransactionItemAction_DOWNGRADE
TransactionItemAction_DOWNGRADED = _transaction.TransactionItemAction_DOWNGRADED
TransactionItemAction_OBSOLETE = _transaction.TransactionItemAction_OBSOLETE
TransactionItemAction_OBSOLETED = _transaction.TransactionItemAction_OBSOLETED
TransactionItemAction_UPGRADE = _transaction.TransactionItemAction_UPGRADE
TransactionItemAction_UPGRADED = _transaction.TransactionItemAction_UPGRADED
TransactionItemAction_REMOVE = _transaction.TransactionItemAction_REMOVE
TransactionItemAction_REINSTALL = _transaction.TransactionItemAction_REINSTALL
TransactionItemAction_REINSTALLED = _transaction.TransactionItemAction_REINSTALLED
TransactionItemAction_REASON_CHANGE = _transaction.TransactionItemAction_REASON_CHANGE
class TransactionStateVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TransactionStateVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TransactionStateVector, name)
    __repr__ = _swig_repr

def iterator(self):
        return _transaction.TransactionStateVector_iterator(self)
    def __iter__(self):
        return self.iterator()

def __nonzero__(self):
        return _transaction.TransactionStateVector___nonzero__(self)

def __bool__(self):
        return _transaction.TransactionStateVector___bool__(self)

def __len__(self):
        return _transaction.TransactionStateVector___len__(self)

def __getslice__(self, i, j):
        return _transaction.TransactionStateVector___getslice__(self, i, j)

def __setslice__(self, *args):
        return _transaction.TransactionStateVector___setslice__(self, *args)

def __delslice__(self, i, j):
        return _transaction.TransactionStateVector___delslice__(self, i, j)

def __delitem__(self, *args):
        return _transaction.TransactionStateVector___delitem__(self, *args)

def __getitem__(self, *args):
        return _transaction.TransactionStateVector___getitem__(self, *args)

def __setitem__(self, *args):
        return _transaction.TransactionStateVector___setitem__(self, *args)

def pop(self):
        return _transaction.TransactionStateVector_pop(self)

def append(self, x):
        return _transaction.TransactionStateVector_append(self, x)

def empty(self):
        return _transaction.TransactionStateVector_empty(self)

def size(self):
        return _transaction.TransactionStateVector_size(self)

def swap(self, v):
        return _transaction.TransactionStateVector_swap(self, v)

def begin(self):
        return _transaction.TransactionStateVector_begin(self)

def end(self):
        return _transaction.TransactionStateVector_end(self)

def rbegin(self):
        return _transaction.TransactionStateVector_rbegin(self)

def rend(self):
        return _transaction.TransactionStateVector_rend(self)

def clear(self):
        return _transaction.TransactionStateVector_clear(self)

def get_allocator(self):
        return _transaction.TransactionStateVector_get_allocator(self)

def pop_back(self):
        return _transaction.TransactionStateVector_pop_back(self)

def erase(self, *args):
        return _transaction.TransactionStateVector_erase(self, *args)

def __init__(self, *args):
        this = _transaction.new_TransactionStateVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

def push_back(self, x):
        return _transaction.TransactionStateVector_push_back(self, x)

def front(self):
        return _transaction.TransactionStateVector_front(self)

def back(self):
        return _transaction.TransactionStateVector_back(self)

def assign(self, n, x):
        return _transaction.TransactionStateVector_assign(self, n, x)

def resize(self, *args):
        return _transaction.TransactionStateVector_resize(self, *args)

def insert(self, *args):
        return _transaction.TransactionStateVector_insert(self, *args)

def reserve(self, n):
        return _transaction.TransactionStateVector_reserve(self, n)

def capacity(self):
        return _transaction.TransactionStateVector_capacity(self)
    __swig_destroy__ = _transaction.delete_TransactionStateVector
    __del__ = lambda self: None
TransactionStateVector_swigregister = _transaction.TransactionStateVector_swigregister
TransactionStateVector_swigregister(TransactionStateVector)

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

def __init__(self, conn):
        this = _transaction.new_Item(conn)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _transaction.delete_Item
    __del__ = lambda self: None

def getId(self):
        return _transaction.Item_getId(self)

def setId(self, value):
        return _transaction.Item_setId(self, value)

def getItemType(self):
        return _transaction.Item_getItemType(self)

def toStr(self):
        return _transaction.Item_toStr(self)

def save(self):
        return _transaction.Item_save(self)
Item_swigregister = _transaction.Item_swigregister
Item_swigregister(Item)

class CompsEnvironmentItem(Item):
    __swig_setmethods__ = {}
    for _s in [Item]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CompsEnvironmentItem, name, value)
    __swig_getmethods__ = {}
    for _s in [Item]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CompsEnvironmentItem, name)
    __repr__ = _swig_repr

def __init__(self, *args):
        this = _transaction.new_CompsEnvironmentItem(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _transaction.delete_CompsEnvironmentItem
    __del__ = lambda self: None

def getEnvironmentId(self):
        return _transaction.CompsEnvironmentItem_getEnvironmentId(self)

def setEnvironmentId(self, value):
        return _transaction.CompsEnvironmentItem_setEnvironmentId(self, value)

def getName(self):
        return _transaction.CompsEnvironmentItem_getName(self)

def setName(self, value):
        return _transaction.CompsEnvironmentItem_setName(self, value)

def getTranslatedName(self):
        return _transaction.CompsEnvironmentItem_getTranslatedName(self)

def setTranslatedName(self, value):
        return _transaction.CompsEnvironmentItem_setTranslatedName(self, value)

def getPackageTypes(self):
        return _transaction.CompsEnvironmentItem_getPackageTypes(self)

def setPackageTypes(self, value):
        return _transaction.CompsEnvironmentItem_setPackageTypes(self, value)

def toStr(self):
        return _transaction.CompsEnvironmentItem_toStr(self)

def getItemType(self):
        return _transaction.CompsEnvironmentItem_getItemType(self)

def save(self):
        return _transaction.CompsEnvironmentItem_save(self)

def addGroup(self, groupId, installed, groupType):
        return _transaction.CompsEnvironmentItem_addGroup(self, groupId, installed, groupType)

def getGroups(self):
        return _transaction.CompsEnvironmentItem_getGroups(self)
    if _newclass:
        getTransactionItem = staticmethod(_transaction.CompsEnvironmentItem_getTransactionItem)
    else:
        getTransactionItem = _transaction.CompsEnvironmentItem_getTransactionItem
    if _newclass:
        getTransactionItemsByPattern = staticmethod(_transaction.CompsEnvironmentItem_getTransactionItemsByPattern)
    else:
        getTransactionItemsByPattern = _transaction.CompsEnvironmentItem_getTransactionItemsByPattern
    if _newclass:
        getTransactionItems = staticmethod(_transaction.CompsEnvironmentItem_getTransactionItems)
    else:
        getTransactionItems = _transaction.CompsEnvironmentItem_getTransactionItems
CompsEnvironmentItem_swigregister = _transaction.CompsEnvironmentItem_swigregister
CompsEnvironmentItem_swigregister(CompsEnvironmentItem)

def CompsEnvironmentItem_getTransactionItem(conn, envid):
    return _transaction.CompsEnvironmentItem_getTransactionItem(conn, envid)
CompsEnvironmentItem_getTransactionItem = _transaction.CompsEnvironmentItem_getTransactionItem

def CompsEnvironmentItem_getTransactionItemsByPattern(conn, pattern):
    return _transaction.CompsEnvironmentItem_getTransactionItemsByPattern(conn, pattern)
CompsEnvironmentItem_getTransactionItemsByPattern = _transaction.CompsEnvironmentItem_getTransactionItemsByPattern

def CompsEnvironmentItem_getTransactionItems(conn, transactionId):
    return _transaction.CompsEnvironmentItem_getTransactionItems(conn, transactionId)
CompsEnvironmentItem_getTransactionItems = _transaction.CompsEnvironmentItem_getTransactionItems

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

def __init__(self, environment):
        this = _transaction.new_CompsEnvironmentGroup(environment)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

def getId(self):
        return _transaction.CompsEnvironmentGroup_getId(self)

def setId(self, value):
        return _transaction.CompsEnvironmentGroup_setId(self, value)

def getEnvironment(self):
        return _transaction.CompsEnvironmentGroup_getEnvironment(self)

def getGroupId(self):
        return _transaction.CompsEnvironmentGroup_getGroupId(self)

def setGroupId(self, value):
        return _transaction.CompsEnvironmentGroup_setGroupId(self, value)

def getInstalled(self):
        return _transaction.CompsEnvironmentGroup_getInstalled(self)

def setInstalled(self, value):
        return _transaction.CompsEnvironmentGroup_setInstalled(self, value)

def getGroupType(self):
        return _transaction.CompsEnvironmentGroup_getGroupType(self)

def setGroupType(self, value):
        return _transaction.CompsEnvironmentGroup_setGroupType(self, value)

def save(self):
        return _transaction.CompsEnvironmentGroup_save(self)
    __swig_destroy__ = _transaction.delete_CompsEnvironmentGroup
    __del__ = lambda self: None
CompsEnvironmentGroup_swigregister = _transaction.CompsEnvironmentGroup_swigregister
CompsEnvironmentGroup_swigregister(CompsEnvironmentGroup)

CompsPackageType_CONDITIONAL = _transaction.CompsPackageType_CONDITIONAL
CompsPackageType_DEFAULT = _transaction.CompsPackageType_DEFAULT
CompsPackageType_MANDATORY = _transaction.CompsPackageType_MANDATORY
CompsPackageType_OPTIONAL = _transaction.CompsPackageType_OPTIONAL

def listToCompsPackageType(types):
    return _transaction.listToCompsPackageType(types)
listToCompsPackageType = _transaction.listToCompsPackageType

def stringToCompsPackageType(str):
    return _transaction.stringToCompsPackageType(str)
stringToCompsPackageType = _transaction.stringToCompsPackageType

def compsPackageTypeToString(type):
    return _transaction.compsPackageTypeToString(type)
compsPackageTypeToString = _transaction.compsPackageTypeToString

def __or__(a, b):
    return _transaction.__or__(a, b)
__or__ = _transaction.__or__

def __and__(a, b):
    return _transaction.__and__(a, b)
__and__ = _transaction.__and__

def __ior__(a, b):
    return _transaction.__ior__(a, b)
__ior__ = _transaction.__ior__

def __iand__(a, b):
    return _transaction.__iand__(a, b)
__iand__ = _transaction.__iand__
class InvalidCompsPackageTypeError(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, InvalidCompsPackageTypeError, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, InvalidCompsPackageTypeError, name)
    __repr__ = _swig_repr

def __init__(self, what):
        this = _transaction.new_InvalidCompsPackageTypeError(what)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _transaction.delete_InvalidCompsPackageTypeError
    __del__ = lambda self: None
InvalidCompsPackageTypeError_swigregister = _transaction.InvalidCompsPackageTypeError_swigregister
InvalidCompsPackageTypeError_swigregister(InvalidCompsPackageTypeError)

class CompsGroupItem(Item):
    __swig_setmethods__ = {}
    for _s in [Item]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CompsGroupItem, name, value)
    __swig_getmethods__ = {}
    for _s in [Item]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CompsGroupItem, name)
    __repr__ = _swig_repr

def __init__(self, *args):
        this = _transaction.new_CompsGroupItem(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _transaction.delete_CompsGroupItem
    __del__ = lambda self: None

def getGroupId(self):
        return _transaction.CompsGroupItem_getGroupId(self)

def setGroupId(self, value):
        return _transaction.CompsGroupItem_setGroupId(self, value)

def getName(self):
        return _transaction.CompsGroupItem_getName(self)

def setName(self, value):
        return _transaction.CompsGroupItem_setName(self, value)

def getTranslatedName(self):
        return _transaction.CompsGroupItem_getTranslatedName(self)

def setTranslatedName(self, value):
        return _transaction.CompsGroupItem_setTranslatedName(self, value)

def getPackageTypes(self):
        return _transaction.CompsGroupItem_getPackageTypes(self)

def setPackageTypes(self, value):
        return _transaction.CompsGroupItem_setPackageTypes(self, value)

def toStr(self):
        return _transaction.CompsGroupItem_toStr(self)

def getItemType(self):
        return _transaction.CompsGroupItem_getItemType(self)

def save(self):
        return _transaction.CompsGroupItem_save(self)

def addPackage(self, name, installed, pkgType):
        return _transaction.CompsGroupItem_addPackage(self, name, installed, pkgType)

def getPackages(self):
        return _transaction.CompsGroupItem_getPackages(self)
    if _newclass:
        getTransactionItem = staticmethod(_transaction.CompsGroupItem_getTransactionItem)
    else:
        getTransactionItem = _transaction.CompsGroupItem_getTransactionItem
    if _newclass:
        getTransactionItemsByPattern = staticmethod(_transaction.CompsGroupItem_getTransactionItemsByPattern)
    else:
        getTransactionItemsByPattern = _transaction.CompsGroupItem_getTransactionItemsByPattern
    if _newclass:
        getTransactionItems = staticmethod(_transaction.CompsGroupItem_getTransactionItems)
    else:
        getTransactionItems = _transaction.CompsGroupItem_getTransactionItems
CompsGroupItem_swigregister = _transaction.CompsGroupItem_swigregister
CompsGroupItem_swigregister(CompsGroupItem)

def CompsGroupItem_getTransactionItem(conn, groupid):
    return _transaction.CompsGroupItem_getTransactionItem(conn, groupid)
CompsGroupItem_getTransactionItem = _transaction.CompsGroupItem_getTransactionItem

def CompsGroupItem_getTransactionItemsByPattern(conn, pattern):
    return _transaction.CompsGroupItem_getTransactionItemsByPattern(conn, pattern)
CompsGroupItem_getTransactionItemsByPattern = _transaction.CompsGroupItem_getTransactionItemsByPattern

def CompsGroupItem_getTransactionItems(conn, transactionId):
    return _transaction.CompsGroupItem_getTransactionItems(conn, transactionId)
CompsGroupItem_getTransactionItems = _transaction.CompsGroupItem_getTransactionItems

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

def __init__(self, group):
        this = _transaction.new_CompsGroupPackage(group)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

def getId(self):
        return _transaction.CompsGroupPackage_getId(self)

def setId(self, value):
        return _transaction.CompsGroupPackage_setId(self, value)

def getGroup(self):
        return _transaction.CompsGroupPackage_getGroup(self)

def getName(self):
        return _transaction.CompsGroupPackage_getName(self)

def setName(self, value):
        return _transaction.CompsGroupPackage_setName(self, value)

def getInstalled(self):
        return _transaction.CompsGroupPackage_getInstalled(self)

def setInstalled(self, value):
        return _transaction.CompsGroupPackage_setInstalled(self, value)

def getPackageType(self):
        return _transaction.CompsGroupPackage_getPackageType(self)

def setPackageType(self, value):
        return _transaction.CompsGroupPackage_setPackageType(self, value)

def save(self):
        return _transaction.CompsGroupPackage_save(self)
    __swig_destroy__ = _transaction.delete_CompsGroupPackage
    __del__ = lambda self: None
CompsGroupPackage_swigregister = _transaction.CompsGroupPackage_swigregister
CompsGroupPackage_swigregister(CompsGroupPackage)

class RPMItem(Item):
    __swig_setmethods__ = {}
    for _s in [Item]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RPMItem, name, value)
    __swig_getmethods__ = {}
    for _s in [Item]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, RPMItem, name)
    __repr__ = _swig_repr

def __init__(self, *args):
        this = _transaction.new_RPMItem(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _transaction.delete_RPMItem
    __del__ = lambda self: None

def getName(self):
        return _transaction.RPMItem_getName(self)

def setName(self, value):
        return _transaction.RPMItem_setName(self, value)

def getEpoch(self):
        return _transaction.RPMItem_getEpoch(self)

def setEpoch(self, value):
        return _transaction.RPMItem_setEpoch(self, value)

def getVersion(self):
        return _transaction.RPMItem_getVersion(self)

def setVersion(self, value):
        return _transaction.RPMItem_setVersion(self, value)

def getRelease(self):
        return _transaction.RPMItem_getRelease(self)

def setRelease(self, value):
        return _transaction.RPMItem_setRelease(self, value)

def getArch(self):
        return _transaction.RPMItem_getArch(self)

def setArch(self, value):
        return _transaction.RPMItem_setArch(self, value)

def getNEVRA(self):
        return _transaction.RPMItem_getNEVRA(self)

def toStr(self):
        return _transaction.RPMItem_toStr(self)

def getItemType(self):
        return _transaction.RPMItem_getItemType(self)

def save(self):
        return _transaction.RPMItem_save(self)
    if _newclass:
        getTransactionItem = staticmethod(_transaction.RPMItem_getTransactionItem)
    else:
        getTransactionItem = _transaction.RPMItem_getTransactionItem
    if _newclass:
        searchTransactions = staticmethod(_transaction.RPMItem_searchTransactions)
    else:
        searchTransactions = _transaction.RPMItem_searchTransactions
    if _newclass:
        getTransactionItems = staticmethod(_transaction.RPMItem_getTransactionItems)
    else:
        getTransactionItems = _transaction.RPMItem_getTransactionItems
    if _newclass:
        resolveTransactionItemReason = staticmethod(_transaction.RPMItem_resolveTransactionItemReason)
    else:
        resolveTransactionItemReason = _transaction.RPMItem_resolveTransactionItemReason

def __lt__(self, other):
        return _transaction.RPMItem___lt__(self, other)
RPMItem_swigregister = _transaction.RPMItem_swigregister
RPMItem_swigregister(RPMItem)

def RPMItem_getTransactionItem(conn, nevra):
    return _transaction.RPMItem_getTransactionItem(conn, nevra)
RPMItem_getTransactionItem = _transaction.RPMItem_getTransactionItem

def RPMItem_searchTransactions(conn, patterns):
    return _transaction.RPMItem_searchTransactions(conn, patterns)
RPMItem_searchTransactions = _transaction.RPMItem_searchTransactions

def RPMItem_getTransactionItems(conn, transaction_id):
    return _transaction.RPMItem_getTransactionItems(conn, transaction_id)
RPMItem_getTransactionItems = _transaction.RPMItem_getTransactionItems

def RPMItem_resolveTransactionItemReason(conn, name, arch, maxTransactionId):
    return _transaction.RPMItem_resolveTransactionItemReason(conn, name, arch, maxTransactionId)
RPMItem_resolveTransactionItemReason = _transaction.RPMItem_resolveTransactionItemReason

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

def __init__(self, *args):
        this = _transaction.new_Swdb(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _transaction.delete_Swdb
    __del__ = lambda self: None

def getConn(self):
        return _transaction.Swdb_getConn(self)
    defaultPath = _transaction.Swdb_defaultPath
    defaultDatabaseName = _transaction.Swdb_defaultDatabaseName

def getPath(self):
        return _transaction.Swdb_getPath(self)

def resetDatabase(self):
        return _transaction.Swdb_resetDatabase(self)

def closeDatabase(self):
        return _transaction.Swdb_closeDatabase(self)

def initTransaction(self):
        return _transaction.Swdb_initTransaction(self)

def beginTransaction(self, *args):
        return _transaction.Swdb_beginTransaction(self, *args)

def endTransaction(self, dtEnd, rpmdbVersionEnd, state):
        return _transaction.Swdb_endTransaction(self, dtEnd, rpmdbVersionEnd, state)

def closeTransaction(self):
        return _transaction.Swdb_closeTransaction(self)

def getItems(self):
        return _transaction.Swdb_getItems(self)

def getLastTransaction(self):
        return _transaction.Swdb_getLastTransaction(self)

def listTransactions(self):
        return _transaction.Swdb_listTransactions(self)

def getCurrent(self):
        return _transaction.Swdb_getCurrent(self)

def addItem(self, item, repoid, action, reason):
        return _transaction.Swdb_addItem(self, item, repoid, action, reason)

def setItemDone(self, nevra):
        return _transaction.Swdb_setItemDone(self, nevra)

def createRPMItem(self):
        return _transaction.Swdb_createRPMItem(self)

def createCompsGroupItem(self):
        return _transaction.Swdb_createCompsGroupItem(self)

def createCompsEnvironmentItem(self):
        return _transaction.Swdb_createCompsEnvironmentItem(self)

def resolveRPMTransactionItemReason(self, name, arch, maxTransactionId):
        return _transaction.Swdb_resolveRPMTransactionItemReason(self, name, arch, maxTransactionId)

def getRPMRepo(self, nevra):
        return _transaction.Swdb_getRPMRepo(self, nevra)

def getRPMTransactionItem(self, nevra):
        return _transaction.Swdb_getRPMTransactionItem(self, nevra)

def searchTransactionsByRPM(self, patterns):
        return _transaction.Swdb_searchTransactionsByRPM(self, patterns)

def getCompsGroupItem(self, groupid):
        return _transaction.Swdb_getCompsGroupItem(self, groupid)

def getCompsGroupItemsByPattern(self, pattern):
        return _transaction.Swdb_getCompsGroupItemsByPattern(self, pattern)

def getPackageCompsGroups(self, packageName):
        return _transaction.Swdb_getPackageCompsGroups(self, packageName)

def getCompsEnvironmentItem(self, envid):
        return _transaction.Swdb_getCompsEnvironmentItem(self, envid)

def getCompsEnvironmentItemsByPattern(self, pattern):
        return _transaction.Swdb_getCompsEnvironmentItemsByPattern(self, pattern)

def getCompsGroupEnvironments(self, groupId):
        return _transaction.Swdb_getCompsGroupEnvironments(self, groupId)

def setReleasever(self, value):
        return _transaction.Swdb_setReleasever(self, value)

def addConsoleOutputLine(self, fileDescriptor, line):
        return _transaction.Swdb_addConsoleOutputLine(self, fileDescriptor, line)

def filterUserinstalled(self, installed):
        return _transaction.Swdb_filterUserinstalled(self, installed)
Swdb_swigregister = _transaction.Swdb_swigregister
Swdb_swigregister(Swdb)

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)
    __repr__ = _swig_repr

def __init__(self, conn, pk):
        this = _transaction.new_Transaction(conn, pk)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _transaction.delete_Transaction
    __del__ = lambda self: None

def __eq__(self, other):
        return _transaction.Transaction___eq__(self, other)

def __lt__(self, other):
        return _transaction.Transaction___lt__(self, other)

def __gt__(self, other):
        return _transaction.Transaction___gt__(self, other)

def getId(self):
        return _transaction.Transaction_getId(self)

def getDtBegin(self):
        return _transaction.Transaction_getDtBegin(self)

def getDtEnd(self):
        return _transaction.Transaction_getDtEnd(self)

def getRpmdbVersionBegin(self):
        return _transaction.Transaction_getRpmdbVersionBegin(self)

def getRpmdbVersionEnd(self):
        return _transaction.Transaction_getRpmdbVersionEnd(self)

def getReleasever(self):
        return _transaction.Transaction_getReleasever(self)

def getUserId(self):
        return _transaction.Transaction_getUserId(self)

def getCmdline(self):
        return _transaction.Transaction_getCmdline(self)

def getState(self):
        return _transaction.Transaction_getState(self)

def getComment(self):
        return _transaction.Transaction_getComment(self)

def getItems(self):
        return _transaction.Transaction_getItems(self)

def getSoftwarePerformedWith(self):
        return _transaction.Transaction_getSoftwarePerformedWith(self)

def getConsoleOutput(self):
        return _transaction.Transaction_getConsoleOutput(self)
Transaction_swigregister = _transaction.Transaction_swigregister
Transaction_swigregister(Transaction)

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

def getItem(self):
        return _transaction.TransactionItemBase_getItem(self)

def setItem(self, value):
        return _transaction.TransactionItemBase_setItem(self, value)

def getCompsEnvironmentItem(self):
        return _transaction.TransactionItemBase_getCompsEnvironmentItem(self)

def getCompsGroupItem(self):
        return _transaction.TransactionItemBase_getCompsGroupItem(self)

def getRPMItem(self):
        return _transaction.TransactionItemBase_getRPMItem(self)

def getRepoid(self):
        return _transaction.TransactionItemBase_getRepoid(self)

def setRepoid(self, value):
        return _transaction.TransactionItemBase_setRepoid(self, value)

def getAction(self):
        return _transaction.TransactionItemBase_getAction(self)

def setAction(self, value):
        return _transaction.TransactionItemBase_setAction(self, value)

def getReason(self):
        return _transaction.TransactionItemBase_getReason(self)

def setReason(self, value):
        return _transaction.TransactionItemBase_setReason(self, value)

def getActionName(self):
        return _transaction.TransactionItemBase_getActionName(self)

def getActionShort(self):
        return _transaction.TransactionItemBase_getActionShort(self)

def getState(self):
        return _transaction.TransactionItemBase_getState(self)

def setState(self, value):
        return _transaction.TransactionItemBase_setState(self, value)

def isForwardAction(self):
        return _transaction.TransactionItemBase_isForwardAction(self)

def isBackwardAction(self):
        return _transaction.TransactionItemBase_isBackwardAction(self)

def __init__(self):
        this = _transaction.new_TransactionItemBase()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _transaction.delete_TransactionItemBase
    __del__ = lambda self: None
TransactionItemBase_swigregister = _transaction.TransactionItemBase_swigregister
TransactionItemBase_swigregister(TransactionItemBase)

class TransactionItem(TransactionItemBase):
    __swig_setmethods__ = {}
    for _s in [TransactionItemBase]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TransactionItem, name, value)
    __swig_getmethods__ = {}
    for _s in [TransactionItemBase]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TransactionItem, name)
    __repr__ = _swig_repr

def __init__(self, *args):
        this = _transaction.new_TransactionItem(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

def getId(self):
        return _transaction.TransactionItem_getId(self)

def setId(self, value):
        return _transaction.TransactionItem_setId(self, value)

def getInstalledBy(self):
        return _transaction.TransactionItem_getInstalledBy(self)

def getReplacedBy(self):
        return _transaction.TransactionItem_getReplacedBy(self)

def addReplacedBy(self, value):
        return _transaction.TransactionItem_addReplacedBy(self, value)

def save(self):
        return _transaction.TransactionItem_save(self)

def saveReplacedBy(self):
        return _transaction.TransactionItem_saveReplacedBy(self)

def saveState(self):
        return _transaction.TransactionItem_saveState(self)

def __hash__(self):
        return _transaction.TransactionItem___hash__(self)

def __eq__(self, *args):
        return _transaction.TransactionItem___eq__(self, *args)

def __lt__(self, *args):
        return _transaction.TransactionItem___lt__(self, *args)
    __swig_destroy__ = _transaction.delete_TransactionItem
    __del__ = lambda self: None
TransactionItem_swigregister = _transaction.TransactionItem_swigregister
TransactionItem_swigregister(TransactionItem)

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

def __init__(self, trans):
        this = _transaction.new_MergedTransaction(trans)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

def merge(self, trans):
        return _transaction.MergedTransaction_merge(self, trans)

def listIds(self):
        return _transaction.MergedTransaction_listIds(self)

def listUserIds(self):
        return _transaction.MergedTransaction_listUserIds(self)

def listCmdlines(self):
        return _transaction.MergedTransaction_listCmdlines(self)

def listStates(self):
        return _transaction.MergedTransaction_listStates(self)

def listReleasevers(self):
        return _transaction.MergedTransaction_listReleasevers(self)

def listComments(self):
        return _transaction.MergedTransaction_listComments(self)

def getDtBegin(self):
        return _transaction.MergedTransaction_getDtBegin(self)

def getDtEnd(self):
        return _transaction.MergedTransaction_getDtEnd(self)

def getRpmdbVersionBegin(self):
        return _transaction.MergedTransaction_getRpmdbVersionBegin(self)

def getRpmdbVersionEnd(self):
        return _transaction.MergedTransaction_getRpmdbVersionEnd(self)

def getSoftwarePerformedWith(self):
        return _transaction.MergedTransaction_getSoftwarePerformedWith(self)

def getConsoleOutput(self):
        return _transaction.MergedTransaction_getConsoleOutput(self)

def getItems(self):
        return _transaction.MergedTransaction_getItems(self)
    __swig_destroy__ = _transaction.delete_MergedTransaction
    __del__ = lambda self: None
MergedTransaction_swigregister = _transaction.MergedTransaction_swigregister
MergedTransaction_swigregister(MergedTransaction)

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

def __init__(self, inputDir, outputFile):
        this = _transaction.new_Transformer(inputDir, outputFile)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

def transform(self):
        return _transaction.Transformer_transform(self)
    if _newclass:
        createDatabase = staticmethod(_transaction.Transformer_createDatabase)
    else:
        createDatabase = _transaction.Transformer_createDatabase
    if _newclass:
        migrateSchema = staticmethod(_transaction.Transformer_migrateSchema)
    else:
        migrateSchema = _transaction.Transformer_migrateSchema
    if _newclass:
        getReason = staticmethod(_transaction.Transformer_getReason)
    else:
        getReason = _transaction.Transformer_getReason
    if _newclass:
        getVersion = staticmethod(_transaction.Transformer_getVersion)
    else:
        getVersion = _transaction.Transformer_getVersion
    __swig_destroy__ = _transaction.delete_Transformer
    __del__ = lambda self: None
Transformer_swigregister = _transaction.Transformer_swigregister
Transformer_swigregister(Transformer)

def Transformer_createDatabase(conn):
    return _transaction.Transformer_createDatabase(conn)
Transformer_createDatabase = _transaction.Transformer_createDatabase

def Transformer_migrateSchema(conn):
    return _transaction.Transformer_migrateSchema(conn)
Transformer_migrateSchema = _transaction.Transformer_migrateSchema

def Transformer_getReason(reason):
    return _transaction.Transformer_getReason(reason)
Transformer_getReason = _transaction.Transformer_getReason

def Transformer_getVersion():
    return _transaction.Transformer_getVersion()
Transformer_getVersion = _transaction.Transformer_getVersion

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