Bypass Manager Pro + Upload

Editing: smartcols.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.2
#
# 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):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _smartcols
else:
    import _smartcols

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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,)

def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr

def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr

def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper

class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)

SHARED_PTR_DISOWN = _smartcols.SHARED_PTR_DISOWN
class Table(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    TermForce_AUTO = _smartcols.Table_TermForce_AUTO
    TermForce_NEVER = _smartcols.Table_TermForce_NEVER
    TermForce_ALWAYS = _smartcols.Table_TermForce_ALWAYS

def __init__(self, *args):
        _smartcols.Table_swiginit(self, _smartcols.new_Table(*args))
    __swig_destroy__ = _smartcols.delete_Table

def setName(self, name):
        return _smartcols.Table_setName(self, name)

def setColumnSeparator(self, separator):
        return _smartcols.Table_setColumnSeparator(self, separator)

def setLineSeparator(self, separator):
        return _smartcols.Table_setLineSeparator(self, separator)

def setSymbols(self, symbols):
        return _smartcols.Table_setSymbols(self, symbols)

def setDefaultSymbols(self):
        return _smartcols.Table_setDefaultSymbols(self)

def setStream(self, stream):
        return _smartcols.Table_setStream(self, stream)

def setTermforce(self, force):
        return _smartcols.Table_setTermforce(self, force)

def setTermwidth(self, width):
        return _smartcols.Table_setTermwidth(self, width)

def getName(self):
        return _smartcols.Table_getName(self)

def getColumnSeparator(self):
        return _smartcols.Table_getColumnSeparator(self)

def getLineSeparator(self):
        return _smartcols.Table_getLineSeparator(self)

def getNumberOfColumns(self):
        return _smartcols.Table_getNumberOfColumns(self)

def getNumberOfLines(self):
        return _smartcols.Table_getNumberOfLines(self)

def getTitle(self):
        return _smartcols.Table_getTitle(self)

def getColumn(self, n):
        return _smartcols.Table_getColumn(self, n)

def getLine(self, n):
        return _smartcols.Table_getLine(self, n)

def getTermforce(self):
        return _smartcols.Table_getTermforce(self)

def getSymbols(self):
        return _smartcols.Table_getSymbols(self)

def getTermwidth(self):
        return _smartcols.Table_getTermwidth(self)

def getStream(self):
        return _smartcols.Table_getStream(self)

def isColorsEnabled(self):
        return _smartcols.Table_isColorsEnabled(self)

def isRaw(self):
        return _smartcols.Table_isRaw(self)

def isAscii(self):
        return _smartcols.Table_isAscii(self)

def isJson(self):
        return _smartcols.Table_isJson(self)

def isNoheadings(self):
        return _smartcols.Table_isNoheadings(self)

def isEmpty(self):
        return _smartcols.Table_isEmpty(self)

def isExport(self):
        return _smartcols.Table_isExport(self)

def isMaxout(self):
        return _smartcols.Table_isMaxout(self)

def isNowrap(self):
        return _smartcols.Table_isNowrap(self)

def isNoLineSeparator(self):
        return _smartcols.Table_isNoLineSeparator(self)

def isTree(self):
        return _smartcols.Table_isTree(self)

def enableColors(self, enable):
        return _smartcols.Table_enableColors(self, enable)

def enableRaw(self, enable):
        return _smartcols.Table_enableRaw(self, enable)

def enableAscii(self, enable):
        return _smartcols.Table_enableAscii(self, enable)

def enableJson(self, enable):
        return _smartcols.Table_enableJson(self, enable)

def enableNoheadings(self, enable):
        return _smartcols.Table_enableNoheadings(self, enable)

def enableExport(self, enable):
        return _smartcols.Table_enableExport(self, enable)

def enableMaxout(self, enable):
        return _smartcols.Table_enableMaxout(self, enable)

def enableNowrap(self, enable):
        return _smartcols.Table_enableNowrap(self, enable)

def enableNolinesep(self, enable):
        return _smartcols.Table_enableNolinesep(self, enable)

def addColumn(self, column):
        return _smartcols.Table_addColumn(self, column)

def removeColumn(self, column):
        return _smartcols.Table_removeColumn(self, column)

def removeColumns(self):
        return _smartcols.Table_removeColumns(self)

def moveColumn(self, before, toMove):
        return _smartcols.Table_moveColumn(self, before, toMove)

def newColumn(self, name, widthHint=0, flags=0):
        return _smartcols.Table_newColumn(self, name, widthHint, flags)

def nextColumn(self, iterator):
        return _smartcols.Table_nextColumn(self, iterator)

def addLine(self, line):
        return _smartcols.Table_addLine(self, line)

def removeLine(self, line):
        return _smartcols.Table_removeLine(self, line)

def removeLines(self):
        return _smartcols.Table_removeLines(self)

def newLine(self, *args):
        return _smartcols.Table_newLine(self, *args)

def nextLine(self, iterator):
        return _smartcols.Table_nextLine(self, iterator)

def reduceTermwidth(self, reduce):
        return _smartcols.Table_reduceTermwidth(self, reduce)

def sort(self, column):
        return _smartcols.Table_sort(self, column)

def sortByTree(self):
        return _smartcols.Table_sortByTree(self)

def _print(self, *args):
        return _smartcols.Table__print(self, *args)

def toString(self, *args):
        return _smartcols.Table_toString(self, *args)

# Register Table in _smartcols:
_smartcols.Table_swigregister(Table)

def wrapNewlineChunksize(column, data, userdata):
    return _smartcols.wrapNewlineChunksize(column, data, userdata)

def wrapNewlineNextchunk(column, data, userdata):
    return _smartcols.wrapNewlineNextchunk(column, data, userdata)
class Column(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

def __init__(self, *args):
        _smartcols.Column_swiginit(self, _smartcols.new_Column(*args))
    __swig_destroy__ = _smartcols.delete_Column

def isTree(self):
        return _smartcols.Column_isTree(self)

def isTrunc(self):
        return _smartcols.Column_isTrunc(self)

def isRight(self):
        return _smartcols.Column_isRight(self)

def isStrictWidth(self):
        return _smartcols.Column_isStrictWidth(self)

def isHidden(self):
        return _smartcols.Column_isHidden(self)

def isNoextremes(self):
        return _smartcols.Column_isNoextremes(self)

def isWrap(self):
        return _smartcols.Column_isWrap(self)

def isCustomwrap(self):
        return _smartcols.Column_isCustomwrap(self)

def getFlags(self):
        return _smartcols.Column_getFlags(self)

def getWidthHint(self):
        return _smartcols.Column_getWidthHint(self)

def getWidth(self):
        return _smartcols.Column_getWidth(self)

def getSafechars(self):
        return _smartcols.Column_getSafechars(self)

def getColor(self):
        return _smartcols.Column_getColor(self)

def getHeader(self):
        return _smartcols.Column_getHeader(self)

def setWrap(self, enable):
        return _smartcols.Column_setWrap(self, enable)

def setColor(self, color):
        return _smartcols.Column_setColor(self, color)

def setFlags(self, flags):
        return _smartcols.Column_setFlags(self, flags)

def setSafechars(self, safe):
        return _smartcols.Column_setSafechars(self, safe)

def setWidthHint(self, hint):
        return _smartcols.Column_setWidthHint(self, hint)

def setCompareFunction(self, function, data):
        return _smartcols.Column_setCompareFunction(self, function, data)

def setWrapFunction(self, wrapChunksize, wrapNextchunk, userdata):
        return _smartcols.Column_setWrapFunction(self, wrapChunksize, wrapNextchunk, userdata)

def setNewlineWrapFunction(self):
        return _smartcols.Column_setNewlineWrapFunction(self)

# Register Column in _smartcols:
_smartcols.Column_swigregister(Column)

class Line(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

def __init__(self, *args):
        _smartcols.Line_swiginit(self, _smartcols.new_Line(*args))
    __swig_destroy__ = _smartcols.delete_Line

def allocCells(self, n):
        return _smartcols.Line_allocCells(self, n)

def freeCells(self):
        return _smartcols.Line_freeCells(self)

def addChild(self, child):
        return _smartcols.Line_addChild(self, child)

def removeChild(self, child):
        return _smartcols.Line_removeChild(self, child)

def nextChild(self, iter):
        return _smartcols.Line_nextChild(self, iter)

def referData(self, n, data):
        return _smartcols.Line_referData(self, n, data)

def referColumnData(self, column, data):
        return _smartcols.Line_referColumnData(self, column, data)

def hasChildren(self):
        return _smartcols.Line_hasChildren(self)

def isAncestor(self, parent):
        return _smartcols.Line_isAncestor(self, parent)

def getCellCount(self):
        return _smartcols.Line_getCellCount(self)

def getColor(self):
        return _smartcols.Line_getColor(self)

def getCell(self, n):
        return _smartcols.Line_getCell(self, n)

def getColumnCell(self, *args):
        return _smartcols.Line_getColumnCell(self, *args)

def getParent(self):
        return _smartcols.Line_getParent(self)

def getUserdata(self):
        return _smartcols.Line_getUserdata(self)

def setUserdata(self, data):
        return _smartcols.Line_setUserdata(self, data)

def setColor(self, color):
        return _smartcols.Line_setColor(self, color)

def setData(self, n, data):
        return _smartcols.Line_setData(self, n, data)

def setColumnData(self, *args):
        return _smartcols.Line_setColumnData(self, *args)

# Register Line in _smartcols:
_smartcols.Line_swigregister(Line)

class Cell(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

def __init__(self, cell):
        _smartcols.Cell_swiginit(self, _smartcols.new_Cell(cell))

def reset(self):
        return _smartcols.Cell_reset(self)

def getFlags(self):
        return _smartcols.Cell_getFlags(self)

def getAlignment(self):
        return _smartcols.Cell_getAlignment(self)

def getData(self):
        return _smartcols.Cell_getData(self)

def getColor(self):
        return _smartcols.Cell_getColor(self)

def getUserdata(self):
        return _smartcols.Cell_getUserdata(self)

def setData(self, data):
        return _smartcols.Cell_setData(self, data)

def setColor(self, color):
        return _smartcols.Cell_setColor(self, color)

def setFlags(self, flags):
        return _smartcols.Cell_setFlags(self, flags)

def setUserdata(self, data):
        return _smartcols.Cell_setUserdata(self, data)

def __eq__(self, cell):
        return _smartcols.Cell___eq__(self, cell)
    __swig_destroy__ = _smartcols.delete_Cell

# Register Cell in _smartcols:
_smartcols.Cell_swigregister(Cell)

[ BATAL ]