Source code for molpher.swig_wrappers.core

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.8
#
# 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
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('_core', [dirname(__file__)])
        except ImportError:
            import _core
            return _core
        if fp is not None:
            try:
                _mod = imp.load_module('_core', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _core = swig_import_helper()
    del swig_import_helper
else:
    import _core
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):
        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_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


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

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


try:
    import weakref
    weakref_proxy = weakref.proxy
except Exception:
    weakref_proxy = lambda x: x


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__ = _core.delete_SwigPyIterator
    __del__ = lambda self: None

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


_core.SHARED_PTR_DISOWN_swigconstant(_core)
SHARED_PTR_DISOWN = _core.SHARED_PTR_DISOWN

def load_data_from(path):
    return _core.load_data_from(path)
load_data_from = _core.load_data_from
class StringSet(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringSet, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringSet, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _core.StringSet_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _core.StringSet___nonzero__(self)

    def __bool__(self):
        return _core.StringSet___bool__(self)

    def __len__(self):
        return _core.StringSet___len__(self)

    def append(self, x):
        return _core.StringSet_append(self, x)

    def __contains__(self, x):
        return _core.StringSet___contains__(self, x)

    def __getitem__(self, i):
        return _core.StringSet___getitem__(self, i)

    def add(self, x):
        return _core.StringSet_add(self, x)

    def discard(self, x):
        return _core.StringSet_discard(self, x)

    def __init__(self, *args):
        this = _core.new_StringSet(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def empty(self):
        return _core.StringSet_empty(self)

    def size(self):
        return _core.StringSet_size(self)

    def clear(self):
        return _core.StringSet_clear(self)

    def swap(self, v):
        return _core.StringSet_swap(self, v)

    def count(self, x):
        return _core.StringSet_count(self, x)

    def begin(self):
        return _core.StringSet_begin(self)

    def end(self):
        return _core.StringSet_end(self)

    def rbegin(self):
        return _core.StringSet_rbegin(self)

    def rend(self):
        return _core.StringSet_rend(self)

    def erase(self, *args):
        return _core.StringSet_erase(self, *args)

    def find(self, x):
        return _core.StringSet_find(self, x)

    def lower_bound(self, x):
        return _core.StringSet_lower_bound(self, x)

    def upper_bound(self, x):
        return _core.StringSet_upper_bound(self, x)

    def equal_range(self, x):
        return _core.StringSet_equal_range(self, x)

    def insert(self, __x):
        return _core.StringSet_insert(self, __x)
    __swig_destroy__ = _core.delete_StringSet
    __del__ = lambda self: None
StringSet_swigregister = _core.StringSet_swigregister
StringSet_swigregister(StringSet)

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

    def iterator(self):
        return _core.IntSet_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _core.IntSet___nonzero__(self)

    def __bool__(self):
        return _core.IntSet___bool__(self)

    def __len__(self):
        return _core.IntSet___len__(self)

    def append(self, x):
        return _core.IntSet_append(self, x)

    def __contains__(self, x):
        return _core.IntSet___contains__(self, x)

    def __getitem__(self, i):
        return _core.IntSet___getitem__(self, i)

    def add(self, x):
        return _core.IntSet_add(self, x)

    def discard(self, x):
        return _core.IntSet_discard(self, x)

    def __init__(self, *args):
        this = _core.new_IntSet(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def empty(self):
        return _core.IntSet_empty(self)

    def size(self):
        return _core.IntSet_size(self)

    def clear(self):
        return _core.IntSet_clear(self)

    def swap(self, v):
        return _core.IntSet_swap(self, v)

    def count(self, x):
        return _core.IntSet_count(self, x)

    def begin(self):
        return _core.IntSet_begin(self)

    def end(self):
        return _core.IntSet_end(self)

    def rbegin(self):
        return _core.IntSet_rbegin(self)

    def rend(self):
        return _core.IntSet_rend(self)

    def erase(self, *args):
        return _core.IntSet_erase(self, *args)

    def find(self, x):
        return _core.IntSet_find(self, x)

    def lower_bound(self, x):
        return _core.IntSet_lower_bound(self, x)

    def upper_bound(self, x):
        return _core.IntSet_upper_bound(self, x)

    def equal_range(self, x):
        return _core.IntSet_equal_range(self, x)

    def insert(self, __x):
        return _core.IntSet_insert(self, __x)
    __swig_destroy__ = _core.delete_IntSet
    __del__ = lambda self: None
IntSet_swigregister = _core.IntSet_swigregister
IntSet_swigregister(IntSet)

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

    def iterator(self):
        return _core.StringVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _core.StringVector___nonzero__(self)

    def __bool__(self):
        return _core.StringVector___bool__(self)

    def __len__(self):
        return _core.StringVector___len__(self)

    def __getslice__(self, i, j):
        return _core.StringVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _core.StringVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _core.StringVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _core.StringVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _core.StringVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _core.StringVector___setitem__(self, *args)

    def pop(self):
        return _core.StringVector_pop(self)

    def append(self, x):
        return _core.StringVector_append(self, x)

    def empty(self):
        return _core.StringVector_empty(self)

    def size(self):
        return _core.StringVector_size(self)

    def swap(self, v):
        return _core.StringVector_swap(self, v)

    def begin(self):
        return _core.StringVector_begin(self)

    def end(self):
        return _core.StringVector_end(self)

    def rbegin(self):
        return _core.StringVector_rbegin(self)

    def rend(self):
        return _core.StringVector_rend(self)

    def clear(self):
        return _core.StringVector_clear(self)

    def get_allocator(self):
        return _core.StringVector_get_allocator(self)

    def pop_back(self):
        return _core.StringVector_pop_back(self)

    def erase(self, *args):
        return _core.StringVector_erase(self, *args)

    def __init__(self, *args):
        this = _core.new_StringVector(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        return _core.StringVector_push_back(self, x)

    def front(self):
        return _core.StringVector_front(self)

    def back(self):
        return _core.StringVector_back(self)

    def assign(self, n, x):
        return _core.StringVector_assign(self, n, x)

    def resize(self, *args):
        return _core.StringVector_resize(self, *args)

    def insert(self, *args):
        return _core.StringVector_insert(self, *args)

    def reserve(self, n):
        return _core.StringVector_reserve(self, n)

    def capacity(self):
        return _core.StringVector_capacity(self)
    __swig_destroy__ = _core.delete_StringVector
    __del__ = lambda self: None
StringVector_swigregister = _core.StringVector_swigregister
StringVector_swigregister(StringVector)

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

    def iterator(self):
        return _core.BoolVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _core.BoolVector___nonzero__(self)

    def __bool__(self):
        return _core.BoolVector___bool__(self)

    def __len__(self):
        return _core.BoolVector___len__(self)

    def __getslice__(self, i, j):
        return _core.BoolVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _core.BoolVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _core.BoolVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _core.BoolVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _core.BoolVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _core.BoolVector___setitem__(self, *args)

    def pop(self):
        return _core.BoolVector_pop(self)

    def append(self, x):
        return _core.BoolVector_append(self, x)

    def empty(self):
        return _core.BoolVector_empty(self)

    def size(self):
        return _core.BoolVector_size(self)

    def swap(self, v):
        return _core.BoolVector_swap(self, v)

    def begin(self):
        return _core.BoolVector_begin(self)

    def end(self):
        return _core.BoolVector_end(self)

    def rbegin(self):
        return _core.BoolVector_rbegin(self)

    def rend(self):
        return _core.BoolVector_rend(self)

    def clear(self):
        return _core.BoolVector_clear(self)

    def get_allocator(self):
        return _core.BoolVector_get_allocator(self)

    def pop_back(self):
        return _core.BoolVector_pop_back(self)

    def erase(self, *args):
        return _core.BoolVector_erase(self, *args)

    def __init__(self, *args):
        this = _core.new_BoolVector(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        return _core.BoolVector_push_back(self, x)

    def front(self):
        return _core.BoolVector_front(self)

    def back(self):
        return _core.BoolVector_back(self)

    def assign(self, n, x):
        return _core.BoolVector_assign(self, n, x)

    def resize(self, *args):
        return _core.BoolVector_resize(self, *args)

    def insert(self, *args):
        return _core.BoolVector_insert(self, *args)

    def reserve(self, n):
        return _core.BoolVector_reserve(self, n)

    def capacity(self):
        return _core.BoolVector_capacity(self)
    __swig_destroy__ = _core.delete_BoolVector
    __del__ = lambda self: None
BoolVector_swigregister = _core.BoolVector_swigregister
BoolVector_swigregister(BoolVector)

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

    def iterator(self):
        return _core.MolpherMolVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _core.MolpherMolVector___nonzero__(self)

    def __bool__(self):
        return _core.MolpherMolVector___bool__(self)

    def __len__(self):
        return _core.MolpherMolVector___len__(self)

    def __getslice__(self, i, j):
        return _core.MolpherMolVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _core.MolpherMolVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _core.MolpherMolVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _core.MolpherMolVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _core.MolpherMolVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _core.MolpherMolVector___setitem__(self, *args)

    def pop(self):
        return _core.MolpherMolVector_pop(self)

    def append(self, x):
        return _core.MolpherMolVector_append(self, x)

    def empty(self):
        return _core.MolpherMolVector_empty(self)

    def size(self):
        return _core.MolpherMolVector_size(self)

    def swap(self, v):
        return _core.MolpherMolVector_swap(self, v)

    def begin(self):
        return _core.MolpherMolVector_begin(self)

    def end(self):
        return _core.MolpherMolVector_end(self)

    def rbegin(self):
        return _core.MolpherMolVector_rbegin(self)

    def rend(self):
        return _core.MolpherMolVector_rend(self)

    def clear(self):
        return _core.MolpherMolVector_clear(self)

    def get_allocator(self):
        return _core.MolpherMolVector_get_allocator(self)

    def pop_back(self):
        return _core.MolpherMolVector_pop_back(self)

    def erase(self, *args):
        return _core.MolpherMolVector_erase(self, *args)

    def __init__(self, *args):
        this = _core.new_MolpherMolVector(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        return _core.MolpherMolVector_push_back(self, x)

    def front(self):
        return _core.MolpherMolVector_front(self)

    def back(self):
        return _core.MolpherMolVector_back(self)

    def assign(self, n, x):
        return _core.MolpherMolVector_assign(self, n, x)

    def resize(self, *args):
        return _core.MolpherMolVector_resize(self, *args)

    def insert(self, *args):
        return _core.MolpherMolVector_insert(self, *args)

    def reserve(self, n):
        return _core.MolpherMolVector_reserve(self, n)

    def capacity(self):
        return _core.MolpherMolVector_capacity(self)
    __swig_destroy__ = _core.delete_MolpherMolVector
    __del__ = lambda self: None
MolpherMolVector_swigregister = _core.MolpherMolVector_swigregister
MolpherMolVector_swigregister(MolpherMolVector)

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

    def iterator(self):
        return _core.MolpherMolMap_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _core.MolpherMolMap___nonzero__(self)

    def __bool__(self):
        return _core.MolpherMolMap___bool__(self)

    def __len__(self):
        return _core.MolpherMolMap___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        return _core.MolpherMolMap___getitem__(self, key)

    def __delitem__(self, key):
        return _core.MolpherMolMap___delitem__(self, key)

    def has_key(self, key):
        return _core.MolpherMolMap_has_key(self, key)

    def keys(self):
        return _core.MolpherMolMap_keys(self)

    def values(self):
        return _core.MolpherMolMap_values(self)

    def items(self):
        return _core.MolpherMolMap_items(self)

    def __contains__(self, key):
        return _core.MolpherMolMap___contains__(self, key)

    def key_iterator(self):
        return _core.MolpherMolMap_key_iterator(self)

    def value_iterator(self):
        return _core.MolpherMolMap_value_iterator(self)

    def __setitem__(self, *args):
        return _core.MolpherMolMap___setitem__(self, *args)

    def asdict(self):
        return _core.MolpherMolMap_asdict(self)

    def __init__(self, *args):
        this = _core.new_MolpherMolMap(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def empty(self):
        return _core.MolpherMolMap_empty(self)

    def size(self):
        return _core.MolpherMolMap_size(self)

    def swap(self, v):
        return _core.MolpherMolMap_swap(self, v)

    def begin(self):
        return _core.MolpherMolMap_begin(self)

    def end(self):
        return _core.MolpherMolMap_end(self)

    def rbegin(self):
        return _core.MolpherMolMap_rbegin(self)

    def rend(self):
        return _core.MolpherMolMap_rend(self)

    def clear(self):
        return _core.MolpherMolMap_clear(self)

    def get_allocator(self):
        return _core.MolpherMolMap_get_allocator(self)

    def count(self, x):
        return _core.MolpherMolMap_count(self, x)

    def erase(self, *args):
        return _core.MolpherMolMap_erase(self, *args)

    def find(self, x):
        return _core.MolpherMolMap_find(self, x)

    def lower_bound(self, x):
        return _core.MolpherMolMap_lower_bound(self, x)

    def upper_bound(self, x):
        return _core.MolpherMolMap_upper_bound(self, x)
    __swig_destroy__ = _core.delete_MolpherMolMap
    __del__ = lambda self: None
MolpherMolMap_swigregister = _core.MolpherMolMap_swigregister
MolpherMolMap_swigregister(MolpherMolMap)

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

    def __init__(self, *args):
        this = _core.new_MolpherMol(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_MolpherMol
    __del__ = lambda self: None

[docs]    def copy(self):
        return _core.MolpherMol_copy(self)

[docs]    def getSMILES(self):
        return _core.MolpherMol_getSMILES(self)

[docs]    def getDistToTarget(self):
        return _core.MolpherMol_getDistToTarget(self)

[docs]    def getTree(self):
        return _core.MolpherMol_getTree(self)

[docs]    def getParentSMILES(self):
        return _core.MolpherMol_getParentSMILES(self)

[docs]    def getDescendants(self):
        return _core.MolpherMol_getDescendants(self)

[docs]    def getHistoricDescendants(self):
        return _core.MolpherMol_getHistoricDescendants(self)

[docs]    def getItersWithoutDistImprovement(self):
        return _core.MolpherMol_getItersWithoutDistImprovement(self)

[docs]    def getSAScore(self):
        return _core.MolpherMol_getSAScore(self)

[docs]    def getMolecularWeight(self):
        return _core.MolpherMol_getMolecularWeight(self)

    def getFormula(self):
        return _core.MolpherMol_getFormula(self)

    def getParentOper(self):
        return _core.MolpherMol_getParentOper(self)

    def setOwner(self, tree):
        return _core.MolpherMol_setOwner(self, tree)

    def setSMILES(self, arg2):
        return _core.MolpherMol_setSMILES(self, arg2)

    def setParentSMILES(self, arg2):
        return _core.MolpherMol_setParentSMILES(self, arg2)

[docs]    def setDistToTarget(self, dist):
        return _core.MolpherMol_setDistToTarget(self, dist)

[docs]    def setSAScore(self, score):
        return _core.MolpherMol_setSAScore(self, score)

[docs]    def setItersWithoutDistImprovement(self, count):
        return _core.MolpherMol_setItersWithoutDistImprovement(self, count)

    def increaseItersWithoutDistImprovement(self):
        return _core.MolpherMol_increaseItersWithoutDistImprovement(self)

    def decreaseItersWithoutDistImprovement(self):
        return _core.MolpherMol_decreaseItersWithoutDistImprovement(self)

    def addToDescendants(self, smiles):
        return _core.MolpherMol_addToDescendants(self, smiles)

    def removeFromDescendants(self, smiles):
        return _core.MolpherMol_removeFromDescendants(self, smiles)

    def setDescendants(self, arg2):
        return _core.MolpherMol_setDescendants(self, arg2)

    def addToHistoricDescendants(self, smiles):
        return _core.MolpherMol_addToHistoricDescendants(self, smiles)

    def removeFromHistoricDescendants(self, smiles):
        return _core.MolpherMol_removeFromHistoricDescendants(self, smiles)

    def setHistoricDescendants(self, arg2):
        return _core.MolpherMol_setHistoricDescendants(self, arg2)

    def isValid(self):
        return _core.MolpherMol_isValid(self)

    def isBoundToTree(self):
        return _core.MolpherMol_isBoundToTree(self)

    def removeFromTree(self):
        return _core.MolpherMol_removeFromTree(self)
MolpherMol_swigregister = _core.MolpherMol_swigregister
MolpherMol_swigregister(MolpherMol)

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

    def __init__(self):
        this = _core.new_ExplorationData()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_ExplorationData
    __del__ = lambda self: None

    def getGenerationCount(self):
        return _core.ExplorationData_getGenerationCount(self)

    def getThreadCount(self):
        return _core.ExplorationData_getThreadCount(self)

[docs]    def getFingerprint(self):
        return _core.ExplorationData_getFingerprint(self)

[docs]    def getSimilarityCoefficient(self):
        return _core.ExplorationData_getSimilarityCoefficient(self)

[docs]    def getChemicalOperators(self):
        return _core.ExplorationData_getChemicalOperators(self)

[docs]    def getMinAcceptableMolecularWeight(self):
        return _core.ExplorationData_getMinAcceptableMolecularWeight(self)

[docs]    def getMaxAcceptableMolecularWeight(self):
        return _core.ExplorationData_getMaxAcceptableMolecularWeight(self)

[docs]    def getCntCandidatesToKeep(self):
        return _core.ExplorationData_getCntCandidatesToKeep(self)

[docs]    def getCntCandidatesToKeepMax(self):
        return _core.ExplorationData_getCntCandidatesToKeepMax(self)

[docs]    def getCntMorphs(self):
        return _core.ExplorationData_getCntMorphs(self)

[docs]    def getCntMorphsInDepth(self):
        return _core.ExplorationData_getCntMorphsInDepth(self)

[docs]    def getDistToTargetDepthSwitch(self):
        return _core.ExplorationData_getDistToTargetDepthSwitch(self)

[docs]    def getCntMaxMorphs(self):
        return _core.ExplorationData_getCntMaxMorphs(self)

[docs]    def getItThreshold(self):
        return _core.ExplorationData_getItThreshold(self)

[docs]    def getSource(self):
        return _core.ExplorationData_getSource(self)

[docs]    def getTarget(self):
        return _core.ExplorationData_getTarget(self)

    def getCandidates(self):
        return _core.ExplorationData_getCandidates(self)

    def getCandidatesMask(self):
        return _core.ExplorationData_getCandidatesMask(self)

    def getTreeMap(self):
        return _core.ExplorationData_getTreeMap(self)

    def getDerivationMap(self):
        return _core.ExplorationData_getDerivationMap(self)

    def setGenerationCount(self, arg2):
        return _core.ExplorationData_setGenerationCount(self, arg2)

    def setThreadCount(self, arg2):
        return _core.ExplorationData_setThreadCount(self, arg2)

[docs]    def setFingerprint(self, arg2):
        return _core.ExplorationData_setFingerprint(self, arg2)

[docs]    def setSimilarityCoefficient(self, arg2):
        return _core.ExplorationData_setSimilarityCoefficient(self, arg2)

[docs]    def setChemicalOperators(self, arg2):
        return _core.ExplorationData_setChemicalOperators(self, arg2)

    def addChemicalOperator(self, arg2):
        return _core.ExplorationData_addChemicalOperator(self, arg2)

    def removeChemicalOperator(self, arg2):
        return _core.ExplorationData_removeChemicalOperator(self, arg2)

[docs]    def setMinAcceptableMolecularWeight(self, arg2):
        return _core.ExplorationData_setMinAcceptableMolecularWeight(self, arg2)

[docs]    def setMaxAcceptableMolecularWeight(self, arg2):
        return _core.ExplorationData_setMaxAcceptableMolecularWeight(self, arg2)

[docs]    def setCntCandidatesToKeep(self, arg2):
        return _core.ExplorationData_setCntCandidatesToKeep(self, arg2)

[docs]    def setCntCandidatesToKeepMax(self, arg2):
        return _core.ExplorationData_setCntCandidatesToKeepMax(self, arg2)

[docs]    def setCntMorphs(self, arg2):
        return _core.ExplorationData_setCntMorphs(self, arg2)

[docs]    def setCntMorphsInDepth(self, arg2):
        return _core.ExplorationData_setCntMorphsInDepth(self, arg2)

[docs]    def setDistToTargetDepthSwitch(self, arg2):
        return _core.ExplorationData_setDistToTargetDepthSwitch(self, arg2)

[docs]    def setCntMaxMorphs(self, arg2):
        return _core.ExplorationData_setCntMaxMorphs(self, arg2)

[docs]    def setItThreshold(self, arg2):
        return _core.ExplorationData_setItThreshold(self, arg2)

[docs]    def setSource(self, arg2):
        return _core.ExplorationData_setSource(self, arg2)

[docs]    def setTarget(self, arg2):
        return _core.ExplorationData_setTarget(self, arg2)

    def setCandidates(self, arg2):
        return _core.ExplorationData_setCandidates(self, arg2)

    def addCandidate(self, *args):
        return _core.ExplorationData_addCandidate(self, *args)

    def removeCandidate(self, index):
        return _core.ExplorationData_removeCandidate(self, index)

    def setCandidatesMask(self, arg2):
        return _core.ExplorationData_setCandidatesMask(self, arg2)

    def setCandidatesMaskAt(self, arg2, arg3):
        return _core.ExplorationData_setCandidatesMaskAt(self, arg2, arg3)

    def addToTreeMap(self, arg2, arg3):
        return _core.ExplorationData_addToTreeMap(self, arg2, arg3)

    def popFromTreeMap(self, arg2):
        return _core.ExplorationData_popFromTreeMap(self, arg2)

    def addToDerivationMap(self, arg2, arg3):
        return _core.ExplorationData_addToDerivationMap(self, arg2, arg3)

    def increaseDerivationsCount(self, arg2):
        return _core.ExplorationData_increaseDerivationsCount(self, arg2)

    def decreaseDerivationsCount(self, arg2):
        return _core.ExplorationData_decreaseDerivationsCount(self, arg2)

    def popFromDerivationMap(self, arg2):
        return _core.ExplorationData_popFromDerivationMap(self, arg2)
    __swig_getmethods__["load"] = lambda x: _core.ExplorationData_load
    if _newclass:
        load = staticmethod(_core.ExplorationData_load)

[docs]    def save(self, file):
        return _core.ExplorationData_save(self, file)

    def isValid(self):
        return _core.ExplorationData_isValid(self)
ExplorationData_swigregister = _core.ExplorationData_swigregister
ExplorationData_swigregister(ExplorationData)

def ExplorationData_load(file):
    return _core.ExplorationData_load(file)
ExplorationData_load = _core.ExplorationData_load

[docs]class ExplorationTree(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ExplorationTree, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ExplorationTree, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_getmethods__["create"] = lambda x: _core.ExplorationTree_create
    if _newclass:
        create = staticmethod(_core.ExplorationTree_create)

[docs]    def asData(self):
        return _core.ExplorationTree_asData(self)

[docs]    def update(self, data):
        return _core.ExplorationTree_update(self, data)

[docs]    def runOperation(self, operation):
        return _core.ExplorationTree_runOperation(self, operation)

[docs]    def fetchLeaves(self, increase_dist_improve_counter=False):
        return _core.ExplorationTree_fetchLeaves(self, increase_dist_improve_counter)

[docs]    def fetchMol(self, canonSMILES):
        return _core.ExplorationTree_fetchMol(self, canonSMILES)

[docs]    def hasMol(self, *args):
        return _core.ExplorationTree_hasMol(self, *args)

    def isPathFound(self):
        return _core.ExplorationTree_isPathFound(self)

[docs]    def deleteSubtree(self, canonSMILES, descendents_only=False):
        return _core.ExplorationTree_deleteSubtree(self, canonSMILES, descendents_only)

[docs]    def generateMorphs(self):
        return _core.ExplorationTree_generateMorphs(self)

[docs]    def sortMorphs(self):
        return _core.ExplorationTree_sortMorphs(self)

[docs]    def filterMorphs(self, *args):
        return _core.ExplorationTree_filterMorphs(self, *args)

[docs]    def extend(self):
        return _core.ExplorationTree_extend(self)

[docs]    def prune(self):
        return _core.ExplorationTree_prune(self)

[docs]    def traverse(self, *args):
        return _core.ExplorationTree_traverse(self, *args)

[docs]    def save(self, filename):
        return _core.ExplorationTree_save(self, filename)

[docs]    def getThreadCount(self):
        return _core.ExplorationTree_getThreadCount(self)

[docs]    def getGenerationCount(self):
        return _core.ExplorationTree_getGenerationCount(self)

[docs]    def getCandidateMorphs(self):
        return _core.ExplorationTree_getCandidateMorphs(self)

[docs]    def getCandidateMorphsMask(self):
        return _core.ExplorationTree_getCandidateMorphsMask(self)

[docs]    def setThreadCount(self, threadCnt):
        return _core.ExplorationTree_setThreadCount(self, threadCnt)

[docs]    def setCandidateMorphsMask(self, arg2):
        return _core.ExplorationTree_setCandidateMorphsMask(self, arg2)
    __swig_destroy__ = _core.delete_ExplorationTree
    __del__ = lambda self: None
ExplorationTree_swigregister = _core.ExplorationTree_swigregister
ExplorationTree_swigregister(ExplorationTree)

def ExplorationTree_create(*args):
    return _core.ExplorationTree_create(*args)
ExplorationTree_create = _core.ExplorationTree_create

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

    def __init__(self, *args):
        if self.__class__ == TreeOperation:
            _self = None
        else:
            _self = self
        this = _core.new_TreeOperation(_self, *args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_TreeOperation
    __del__ = lambda self: None

[docs]    def __call__(self):
        return _core.TreeOperation___call__(self)

[docs]    def getTree(self):
        return _core.TreeOperation_getTree(self)

[docs]    def setTree(self, tree):
        return _core.TreeOperation_setTree(self, tree)
    def __disown__(self):
        self.this.disown()
        _core.disown_TreeOperation(self)
        return weakref_proxy(self)
TreeOperation_swigregister = _core.TreeOperation_swigregister
TreeOperation_swigregister(TreeOperation)

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

    def __init__(self, *args):
        this = _core.new_FindLeavesOper(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

[docs]    def __call__(self):
        return _core.FindLeavesOper___call__(self)

[docs]    def fetchLeaves(self):
        return _core.FindLeavesOper_fetchLeaves(self)
    __swig_destroy__ = _core.delete_FindLeavesOper
    __del__ = lambda self: None
FindLeavesOper_swigregister = _core.FindLeavesOper_swigregister
FindLeavesOper_swigregister(FindLeavesOper)

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

    def __init__(self, *args):
        this = _core.new_GenerateMorphsOper(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

[docs]    def __call__(self):
        return _core.GenerateMorphsOper___call__(self)
    __swig_destroy__ = _core.delete_GenerateMorphsOper
    __del__ = lambda self: None
GenerateMorphsOper_swigregister = _core.GenerateMorphsOper_swigregister
GenerateMorphsOper_swigregister(GenerateMorphsOper)

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

    def __init__(self, *args):
        this = _core.new_SortMorphsOper(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

[docs]    def __call__(self):
        return _core.SortMorphsOper___call__(self)
    __swig_destroy__ = _core.delete_SortMorphsOper
    __del__ = lambda self: None
SortMorphsOper_swigregister = _core.SortMorphsOper_swigregister
SortMorphsOper_swigregister(SortMorphsOper)

[docs]class FilterMorphsOper(TreeOperation):
    __swig_setmethods__ = {}
    for _s in [TreeOperation]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FilterMorphsOper, name, value)
    __swig_getmethods__ = {}
    for _s in [TreeOperation]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, FilterMorphsOper, name)
    __repr__ = _swig_repr
    PROBABILITY = _core.FilterMorphsOper_PROBABILITY
    WEIGHT = _core.FilterMorphsOper_WEIGHT
    SYNTHESIS = _core.FilterMorphsOper_SYNTHESIS
    MAX_DERIVATIONS = _core.FilterMorphsOper_MAX_DERIVATIONS
    DUPLICATES = _core.FilterMorphsOper_DUPLICATES
    HISTORIC_DESCENDENTS = _core.FilterMorphsOper_HISTORIC_DESCENDENTS
    ALL = _core.FilterMorphsOper_ALL

    def __init__(self, *args):
        this = _core.new_FilterMorphsOper(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __call__(self):
        return _core.FilterMorphsOper___call__(self)
    __swig_destroy__ = _core.delete_FilterMorphsOper
    __del__ = lambda self: None
FilterMorphsOper_swigregister = _core.FilterMorphsOper_swigregister
FilterMorphsOper_swigregister(FilterMorphsOper)

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

    def __init__(self, *args):
        this = _core.new_ExtendTreeOper(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

[docs]    def __call__(self):
        return _core.ExtendTreeOper___call__(self)
    __swig_destroy__ = _core.delete_ExtendTreeOper
    __del__ = lambda self: None
ExtendTreeOper_swigregister = _core.ExtendTreeOper_swigregister
ExtendTreeOper_swigregister(ExtendTreeOper)

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

    def __init__(self, *args):
        this = _core.new_PruneTreeOper(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

[docs]    def __call__(self):
        return _core.PruneTreeOper___call__(self)
    __swig_destroy__ = _core.delete_PruneTreeOper
    __del__ = lambda self: None
PruneTreeOper_swigregister = _core.PruneTreeOper_swigregister
PruneTreeOper_swigregister(PruneTreeOper)

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

    def __init__(self, *args):
        this = _core.new_TraverseOper(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

[docs]    def __call__(self):
        return _core.TraverseOper___call__(self)
    __swig_destroy__ = _core.delete_TraverseOper
    __del__ = lambda self: None
TraverseOper_swigregister = _core.TraverseOper_swigregister
TraverseOper_swigregister(TraverseOper)

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

    def __init__(self):
        if self.__class__ == TraverseCallback:
            _self = None
        else:
            _self = self
        this = _core.new_TraverseCallback(_self, )
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _core.delete_TraverseCallback
    __del__ = lambda self: None

[docs]    def __call__(self, morph):
        return _core.TraverseCallback___call__(self, morph)
    def __disown__(self):
        self.this.disown()
        _core.disown_TraverseCallback(self)
        return weakref_proxy(self)
TraverseCallback_swigregister = _core.TraverseCallback_swigregister
TraverseCallback_swigregister(TraverseCallback)


_core.OP_ADD_ATOM_swigconstant(_core)
OP_ADD_ATOM = _core.OP_ADD_ATOM

_core.OP_REMOVE_ATOM_swigconstant(_core)
OP_REMOVE_ATOM = _core.OP_REMOVE_ATOM

_core.OP_ADD_BOND_swigconstant(_core)
OP_ADD_BOND = _core.OP_ADD_BOND

_core.OP_REMOVE_BOND_swigconstant(_core)
OP_REMOVE_BOND = _core.OP_REMOVE_BOND

_core.OP_MUTATE_ATOM_swigconstant(_core)
OP_MUTATE_ATOM = _core.OP_MUTATE_ATOM

_core.OP_INTERLAY_ATOM_swigconstant(_core)
OP_INTERLAY_ATOM = _core.OP_INTERLAY_ATOM

_core.OP_BOND_REROUTE_swigconstant(_core)
OP_BOND_REROUTE = _core.OP_BOND_REROUTE

_core.OP_BOND_CONTRACTION_swigconstant(_core)
OP_BOND_CONTRACTION = _core.OP_BOND_CONTRACTION

def ChemOperShortDesc(selector):
    return _core.ChemOperShortDesc(selector)
ChemOperShortDesc = _core.ChemOperShortDesc

def ChemOperLongDesc(selector):
    return _core.ChemOperLongDesc(selector)
ChemOperLongDesc = _core.ChemOperLongDesc

_core.FP_ATOM_PAIRS_swigconstant(_core)
FP_ATOM_PAIRS = _core.FP_ATOM_PAIRS

_core.FP_MORGAN_swigconstant(_core)
FP_MORGAN = _core.FP_MORGAN

_core.FP_TOPOLOGICAL_swigconstant(_core)
FP_TOPOLOGICAL = _core.FP_TOPOLOGICAL

_core.FP_TOPOLOGICAL_LAYERED_1_swigconstant(_core)
FP_TOPOLOGICAL_LAYERED_1 = _core.FP_TOPOLOGICAL_LAYERED_1

_core.FP_TOPOLOGICAL_LAYERED_2_swigconstant(_core)
FP_TOPOLOGICAL_LAYERED_2 = _core.FP_TOPOLOGICAL_LAYERED_2

_core.FP_VECTORFP_swigconstant(_core)
FP_VECTORFP = _core.FP_VECTORFP

_core.FP_TOPOLOGICAL_TORSION_swigconstant(_core)
FP_TOPOLOGICAL_TORSION = _core.FP_TOPOLOGICAL_TORSION

_core.FP_EXT_ATOM_PAIRS_swigconstant(_core)
FP_EXT_ATOM_PAIRS = _core.FP_EXT_ATOM_PAIRS

_core.FP_EXT_MORGAN_swigconstant(_core)
FP_EXT_MORGAN = _core.FP_EXT_MORGAN

_core.FP_EXT_TOPOLOGICAL_swigconstant(_core)
FP_EXT_TOPOLOGICAL = _core.FP_EXT_TOPOLOGICAL

_core.FP_EXT_TOPOLOGICAL_LAYERED_1_swigconstant(_core)
FP_EXT_TOPOLOGICAL_LAYERED_1 = _core.FP_EXT_TOPOLOGICAL_LAYERED_1

_core.FP_EXT_TOPOLOGICAL_LAYERED_2_swigconstant(_core)
FP_EXT_TOPOLOGICAL_LAYERED_2 = _core.FP_EXT_TOPOLOGICAL_LAYERED_2

_core.FP_EXT_TOPOLOGICAL_TORSION_swigconstant(_core)
FP_EXT_TOPOLOGICAL_TORSION = _core.FP_EXT_TOPOLOGICAL_TORSION

def FingerprintShortDesc(selector):
    return _core.FingerprintShortDesc(selector)
FingerprintShortDesc = _core.FingerprintShortDesc

def FingerprintLongDesc(selector):
    return _core.FingerprintLongDesc(selector)
FingerprintLongDesc = _core.FingerprintLongDesc

def FingerprintParse(name):
    return _core.FingerprintParse(name)
FingerprintParse = _core.FingerprintParse

_core.SC_ALL_BIT_swigconstant(_core)
SC_ALL_BIT = _core.SC_ALL_BIT

_core.SC_ASYMMETRIC_swigconstant(_core)
SC_ASYMMETRIC = _core.SC_ASYMMETRIC

_core.SC_BRAUN_BLANQUET_swigconstant(_core)
SC_BRAUN_BLANQUET = _core.SC_BRAUN_BLANQUET

_core.SC_COSINE_swigconstant(_core)
SC_COSINE = _core.SC_COSINE

_core.SC_DICE_swigconstant(_core)
SC_DICE = _core.SC_DICE

_core.SC_KULCZYNSKI_swigconstant(_core)
SC_KULCZYNSKI = _core.SC_KULCZYNSKI

_core.SC_MC_CONNAUGHEY_swigconstant(_core)
SC_MC_CONNAUGHEY = _core.SC_MC_CONNAUGHEY

_core.SC_ON_BIT_swigconstant(_core)
SC_ON_BIT = _core.SC_ON_BIT

_core.SC_RUSSEL_swigconstant(_core)
SC_RUSSEL = _core.SC_RUSSEL

_core.SC_SOKAL_swigconstant(_core)
SC_SOKAL = _core.SC_SOKAL

_core.SC_TANIMOTO_swigconstant(_core)
SC_TANIMOTO = _core.SC_TANIMOTO

_core.SC_TVERSKY_SUBSTRUCTURE_swigconstant(_core)
SC_TVERSKY_SUBSTRUCTURE = _core.SC_TVERSKY_SUBSTRUCTURE

_core.SC_TVERSKY_SUPERSTRUCTURE_swigconstant(_core)
SC_TVERSKY_SUPERSTRUCTURE = _core.SC_TVERSKY_SUPERSTRUCTURE

def SimCoeffShortDesc(selector):
    return _core.SimCoeffShortDesc(selector)
SimCoeffShortDesc = _core.SimCoeffShortDesc

def SimCoeffLongDesc(selector):
    return _core.SimCoeffLongDesc(selector)
SimCoeffLongDesc = _core.SimCoeffLongDesc

def SimCoeffParse(name):
    return _core.SimCoeffParse(name)
SimCoeffParse = _core.SimCoeffParse
# This file is compatible with both classic and new-style classes.