Source code for molpher.swig_wrappers.core

# 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, '_core')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_core')
    _core = 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('_core', [dirname(__file__)])
        except ImportError:
            import _core
            return _core
        try:
            _mod = imp.load_module('_core', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _core = swig_import_helper()
    del swig_import_helper
else:
    import _core
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

try:
    import weakref
    weakref_proxy = weakref.proxy
except __builtin__.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)

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

def set_random_seed(seed):
    return _core.set_random_seed(seed)
set_random_seed = _core.set_random_seed

def get_random_number(min, max):
    return _core.get_random_number(min, max)
get_random_number = _core.get_random_number
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 __builtin__.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 __builtin__.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 __builtin__.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 IntVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IntVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IntVector, name)
    __repr__ = _swig_repr

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def capacity(self):
        return _core.IntVector_capacity(self)
    __swig_destroy__ = _core.delete_IntVector
    __del__ = lambda self: None
IntVector_swigregister = _core.IntVector_swigregister
IntVector_swigregister(IntVector)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def capacity(self):
        return _core.UIntVector_capacity(self)
    __swig_destroy__ = _core.delete_UIntVector
    __del__ = lambda self: None
UIntVector_swigregister = _core.UIntVector_swigregister
UIntVector_swigregister(UIntVector)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def capacity(self):
        return _core.UIntVectorPairVector_capacity(self)
    __swig_destroy__ = _core.delete_UIntVectorPairVector
    __del__ = lambda self: None
UIntVectorPairVector_swigregister = _core.UIntVectorPairVector_swigregister
UIntVectorPairVector_swigregister(UIntVectorPairVector)

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 __builtin__.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 __builtin__.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 __builtin__.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)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def capacity(self):
        return _core.MolpherAtomVector_capacity(self)
    __swig_destroy__ = _core.delete_MolpherAtomVector
    __del__ = lambda self: None
MolpherAtomVector_swigregister = _core.MolpherAtomVector_swigregister
MolpherAtomVector_swigregister(MolpherAtomVector)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def capacity(self):
        return _core.MorphingOperatorVector_capacity(self)
    __swig_destroy__ = _core.delete_MorphingOperatorVector
    __del__ = lambda self: None
MorphingOperatorVector_swigregister = _core.MorphingOperatorVector_swigregister
MorphingOperatorVector_swigregister(MorphingOperatorVector)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def capacity(self):
        return _core.MorphCollectorVector_capacity(self)
    __swig_destroy__ = _core.delete_MorphCollectorVector
    __del__ = lambda self: None
MorphCollectorVector_swigregister = _core.MorphCollectorVector_swigregister
MorphCollectorVector_swigregister(MorphCollectorVector)

[docs]class MolpherAtom(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, MolpherAtom, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, MolpherAtom, name) __repr__ = _swig_repr UNLOCKED = _core.MolpherAtom_UNLOCKED NO_MUTATION = _core.MolpherAtom_NO_MUTATION NO_ADDITION = _core.MolpherAtom_NO_ADDITION NO_REMOVAL = _core.MolpherAtom_NO_REMOVAL KEEP_NEIGHBORS = _core.MolpherAtom_KEEP_NEIGHBORS KEEP_NEIGHBORS_AND_BONDS = _core.MolpherAtom_KEEP_NEIGHBORS_AND_BONDS KEEP_BONDS = _core.MolpherAtom_KEEP_BONDS FULL_LOCK = _core.MolpherAtom_FULL_LOCK if _newclass: lockToString = staticmethod(_core.MolpherAtom_lockToString) else: lockToString = _core.MolpherAtom_lockToString if _newclass: lockingMaskToString = staticmethod(_core.MolpherAtom_lockingMaskToString) else: lockingMaskToString = _core.MolpherAtom_lockingMaskToString def __init__(self, *args): this = _core.new_MolpherAtom(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _core.delete_MolpherAtom __del__ = lambda self: None
[docs] def isLocked(self): return _core.MolpherAtom_isLocked(self)
[docs] def getLockingMask(self): return _core.MolpherAtom_getLockingMask(self)
[docs] def getAtomicNum(self): return _core.MolpherAtom_getAtomicNum(self)
[docs] def getMass(self): return _core.MolpherAtom_getMass(self)
[docs] def getFormalCharge(self): return _core.MolpherAtom_getFormalCharge(self)
[docs] def getSymbol(self): return _core.MolpherAtom_getSymbol(self)
[docs] def setLockingMask(self, mask): return _core.MolpherAtom_setLockingMask(self, mask)
[docs] def setFormalCharge(self, charge): return _core.MolpherAtom_setFormalCharge(self, charge)
MolpherAtom_swigregister = _core.MolpherAtom_swigregister MolpherAtom_swigregister(MolpherAtom) cvar = _core.cvar MolpherAtom.atom_locks = _core.cvar.MolpherAtom_atom_locks def MolpherAtom_lockToString(lock): return _core.MolpherAtom_lockToString(lock) MolpherAtom_lockToString = _core.MolpherAtom_lockToString def MolpherAtom_lockingMaskToString(mask): return _core.MolpherAtom_lockingMaskToString(mask) MolpherAtom_lockingMaskToString = _core.MolpherAtom_lockingMaskToString
[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 if _newclass: fromMolBlock = staticmethod(_core.MolpherMol_fromMolBlock) else: fromMolBlock = _core.MolpherMol_fromMolBlock def __init__(self, *args): this = _core.new_MolpherMol(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _core.delete_MolpherMol __del__ = lambda self: None
[docs] def copy(self): return _core.MolpherMol_copy(self)
def asMolBlock(self, include_locks=False): return _core.MolpherMol_asMolBlock(self, include_locks) def lockAtom(self, idx, mask): return _core.MolpherMol_lockAtom(self, idx, mask) def getAtom(self, idx): return _core.MolpherMol_getAtom(self, idx) def getAtoms(self): return _core.MolpherMol_getAtoms(self) def getNeighbors(self, idx): return _core.MolpherMol_getNeighbors(self, idx) def getAtomCount(self): return _core.MolpherMol_getAtomCount(self)
[docs] def lockAtoms(self, *args): return _core.MolpherMol_lockAtoms(self, *args)
[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) def setParentOper(self, arg2): return _core.MolpherMol_setParentOper(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) def MolpherMol_fromMolBlock(mol_block): return _core.MolpherMol_fromMolBlock(mol_block) MolpherMol_fromMolBlock = _core.MolpherMol_fromMolBlock
[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 __builtin__.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) if _newclass: load = staticmethod(_core.ExplorationData_load) else: load = _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 if _newclass: create = staticmethod(_core.ExplorationTree_create) else: create = _core.ExplorationTree_create
[docs] def asData(self): return _core.ExplorationTree_asData(self)
[docs] def update(self, data): return _core.ExplorationTree_update(self, data)
def getMorphingOperators(self): return _core.ExplorationTree_getMorphingOperators(self) def setMorphingOperators(self, operators): return _core.ExplorationTree_setMorphingOperators(self, operators) def addMorphingOperator(self, operator_): return _core.ExplorationTree_addMorphingOperator(self, operator_)
[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, *args): return _core.ExplorationTree_generateMorphs(self, *args)
[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 __builtin__.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 __builtin__.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 __builtin__.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 __builtin__.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 __builtin__.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 __builtin__.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 __builtin__.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 __builtin__.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 CleanMorphsOper(TreeOperation): __swig_setmethods__ = {} for _s in [TreeOperation]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, CleanMorphsOper, name, value) __swig_getmethods__ = {} for _s in [TreeOperation]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, CleanMorphsOper, name) __repr__ = _swig_repr def __init__(self, *args): this = _core.new_CleanMorphsOper(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this
[docs] def __call__(self): return _core.CleanMorphsOper___call__(self)
__swig_destroy__ = _core.delete_CleanMorphsOper __del__ = lambda self: None
CleanMorphsOper_swigregister = _core.CleanMorphsOper_swigregister CleanMorphsOper_swigregister(CleanMorphsOper)
[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 __builtin__.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)
[docs]class SortMorphsCallback(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, SortMorphsCallback, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, SortMorphsCallback, name) __repr__ = _swig_repr def __init__(self): if self.__class__ == SortMorphsCallback: _self = None else: _self = self this = _core.new_SortMorphsCallback(_self, ) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _core.delete_SortMorphsCallback __del__ = lambda self: None
[docs] def __call__(self, morph_1, morph_2): return _core.SortMorphsCallback___call__(self, morph_1, morph_2)
def __disown__(self): self.this.disown() _core.disown_SortMorphsCallback(self) return weakref_proxy(self)
SortMorphsCallback_swigregister = _core.SortMorphsCallback_swigregister SortMorphsCallback_swigregister(SortMorphsCallback) class DefaultSortCallback(SortMorphsCallback): __swig_setmethods__ = {} for _s in [SortMorphsCallback]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, DefaultSortCallback, name, value) __swig_getmethods__ = {} for _s in [SortMorphsCallback]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, DefaultSortCallback, name) __repr__ = _swig_repr def __init__(self): this = _core.new_DefaultSortCallback() try: self.this.append(this) except __builtin__.Exception: self.this = this def __call__(self, morph_1, morph_2): return _core.DefaultSortCallback___call__(self, morph_1, morph_2) __swig_destroy__ = _core.delete_DefaultSortCallback __del__ = lambda self: None DefaultSortCallback_swigregister = _core.DefaultSortCallback_swigregister DefaultSortCallback_swigregister(DefaultSortCallback) OP_ADD_ATOM = _core.OP_ADD_ATOM OP_REMOVE_ATOM = _core.OP_REMOVE_ATOM OP_ADD_BOND = _core.OP_ADD_BOND OP_REMOVE_BOND = _core.OP_REMOVE_BOND OP_MUTATE_ATOM = _core.OP_MUTATE_ATOM OP_INTERLAY_ATOM = _core.OP_INTERLAY_ATOM OP_BOND_REROUTE = _core.OP_BOND_REROUTE 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 FP_ATOM_PAIRS = _core.FP_ATOM_PAIRS FP_MORGAN = _core.FP_MORGAN FP_TOPOLOGICAL = _core.FP_TOPOLOGICAL FP_TOPOLOGICAL_LAYERED_1 = _core.FP_TOPOLOGICAL_LAYERED_1 FP_TOPOLOGICAL_LAYERED_2 = _core.FP_TOPOLOGICAL_LAYERED_2 FP_VECTORFP = _core.FP_VECTORFP FP_TOPOLOGICAL_TORSION = _core.FP_TOPOLOGICAL_TORSION FP_EXT_ATOM_PAIRS = _core.FP_EXT_ATOM_PAIRS FP_EXT_MORGAN = _core.FP_EXT_MORGAN FP_EXT_TOPOLOGICAL = _core.FP_EXT_TOPOLOGICAL FP_EXT_TOPOLOGICAL_LAYERED_1 = _core.FP_EXT_TOPOLOGICAL_LAYERED_1 FP_EXT_TOPOLOGICAL_LAYERED_2 = _core.FP_EXT_TOPOLOGICAL_LAYERED_2 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 SC_ALL_BIT = _core.SC_ALL_BIT SC_ASYMMETRIC = _core.SC_ASYMMETRIC SC_BRAUN_BLANQUET = _core.SC_BRAUN_BLANQUET SC_COSINE = _core.SC_COSINE SC_DICE = _core.SC_DICE SC_KULCZYNSKI = _core.SC_KULCZYNSKI SC_MC_CONNAUGHEY = _core.SC_MC_CONNAUGHEY SC_ON_BIT = _core.SC_ON_BIT SC_RUSSEL = _core.SC_RUSSEL SC_SOKAL = _core.SC_SOKAL SC_TANIMOTO = _core.SC_TANIMOTO SC_TVERSKY_SUBSTRUCTURE = _core.SC_TVERSKY_SUBSTRUCTURE 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
[docs]class AtomLibrary(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, AtomLibrary, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, AtomLibrary, name) __repr__ = _swig_repr def __init__(self, *args): this = _core.new_AtomLibrary(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _core.delete_AtomLibrary __del__ = lambda self: None if _newclass: getDefaultLibrary = staticmethod(_core.AtomLibrary_getDefaultLibrary) else: getDefaultLibrary = _core.AtomLibrary_getDefaultLibrary if _newclass: setDefaultLibrary = staticmethod(_core.AtomLibrary_setDefaultLibrary) else: setDefaultLibrary = _core.AtomLibrary_setDefaultLibrary
[docs] def getRandomAtom(self): return _core.AtomLibrary_getRandomAtom(self)
[docs] def getAtoms(self): return _core.AtomLibrary_getAtoms(self)
AtomLibrary_swigregister = _core.AtomLibrary_swigregister AtomLibrary_swigregister(AtomLibrary) def AtomLibrary_getDefaultLibrary(): return _core.AtomLibrary_getDefaultLibrary() AtomLibrary_getDefaultLibrary = _core.AtomLibrary_getDefaultLibrary def AtomLibrary_setDefaultLibrary(new_default): return _core.AtomLibrary_setDefaultLibrary(new_default) AtomLibrary_setDefaultLibrary = _core.AtomLibrary_setDefaultLibrary
[docs]class Molpher(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, Molpher, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, Molpher, name) __repr__ = _swig_repr def __init__(self, *args): this = _core.new_Molpher(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _core.delete_Molpher __del__ = lambda self: None def __call__(self): return _core.Molpher___call__(self)
[docs] def getMorphs(self): return _core.Molpher_getMorphs(self)
[docs] def getOriginal(self): return _core.Molpher_getOriginal(self)
[docs] def reset(self, original): return _core.Molpher_reset(self, original)
Molpher_swigregister = _core.Molpher_swigregister Molpher_swigregister(Molpher) class MorphCollector(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, MorphCollector, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, MorphCollector, name) __repr__ = _swig_repr def __init__(self): if self.__class__ == MorphCollector: _self = None else: _self = self this = _core.new_MorphCollector(_self, ) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _core.delete_MorphCollector __del__ = lambda self: None def __call__(self, morph, operator_): return _core.MorphCollector___call__(self, morph, operator_) def __disown__(self): self.this.disown() _core.disown_MorphCollector(self) return weakref_proxy(self) MorphCollector_swigregister = _core.MorphCollector_swigregister MorphCollector_swigregister(MorphCollector)
[docs]class MorphingOperator(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, MorphingOperator, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, MorphingOperator, name) __repr__ = _swig_repr def __init__(self): if self.__class__ == MorphingOperator: _self = None else: _self = self this = _core.new_MorphingOperator(_self, ) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _core.delete_MorphingOperator __del__ = lambda self: None
[docs] def getOriginal(self): return _core.MorphingOperator_getOriginal(self)
[docs] def setOriginal(self, arg0): return _core.MorphingOperator_setOriginal(self, arg0)
[docs] def morph(self): return _core.MorphingOperator_morph(self)
[docs] def getName(self): return _core.MorphingOperator_getName(self)
def __disown__(self): self.this.disown() _core.disown_MorphingOperator(self) return weakref_proxy(self)
MorphingOperator_swigregister = _core.MorphingOperator_swigregister MorphingOperator_swigregister(MorphingOperator) class AddAtom(MorphingOperator): __swig_setmethods__ = {} for _s in [MorphingOperator]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, AddAtom, name, value) __swig_getmethods__ = {} for _s in [MorphingOperator]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, AddAtom, name) __repr__ = _swig_repr def __init__(self, *args): this = _core.new_AddAtom(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def setOriginal(self, mol): return _core.AddAtom_setOriginal(self, mol) def morph(self): return _core.AddAtom_morph(self) def getName(self): return _core.AddAtom_getName(self) def getOpenIndices(self): return _core.AddAtom_getOpenIndices(self) def getOpenAtoms(self): return _core.AddAtom_getOpenAtoms(self) __swig_destroy__ = _core.delete_AddAtom __del__ = lambda self: None AddAtom_swigregister = _core.AddAtom_swigregister AddAtom_swigregister(AddAtom) class RemoveAtom(MorphingOperator): __swig_setmethods__ = {} for _s in [MorphingOperator]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, RemoveAtom, name, value) __swig_getmethods__ = {} for _s in [MorphingOperator]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, RemoveAtom, name) __repr__ = _swig_repr def __init__(self): this = _core.new_RemoveAtom() try: self.this.append(this) except __builtin__.Exception: self.this = this def setOriginal(self, mol): return _core.RemoveAtom_setOriginal(self, mol) def morph(self): return _core.RemoveAtom_morph(self) def getName(self): return _core.RemoveAtom_getName(self) def getMarkedIndices(self): return _core.RemoveAtom_getMarkedIndices(self) def getMarkedAtoms(self): return _core.RemoveAtom_getMarkedAtoms(self) __swig_destroy__ = _core.delete_RemoveAtom __del__ = lambda self: None RemoveAtom_swigregister = _core.RemoveAtom_swigregister RemoveAtom_swigregister(RemoveAtom) class MutateAtom(MorphingOperator): __swig_setmethods__ = {} for _s in [MorphingOperator]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, MutateAtom, name, value) __swig_getmethods__ = {} for _s in [MorphingOperator]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, MutateAtom, name) __repr__ = _swig_repr def __init__(self, *args): this = _core.new_MutateAtom(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def setOriginal(self, mol): return _core.MutateAtom_setOriginal(self, mol) def morph(self): return _core.MutateAtom_morph(self) def getName(self): return _core.MutateAtom_getName(self) __swig_destroy__ = _core.delete_MutateAtom __del__ = lambda self: None MutateAtom_swigregister = _core.MutateAtom_swigregister MutateAtom_swigregister(MutateAtom) class AddBond(MorphingOperator): __swig_setmethods__ = {} for _s in [MorphingOperator]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, AddBond, name, value) __swig_getmethods__ = {} for _s in [MorphingOperator]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, AddBond, name) __repr__ = _swig_repr def __init__(self): this = _core.new_AddBond() try: self.this.append(this) except __builtin__.Exception: self.this = this def setOriginal(self, mol): return _core.AddBond_setOriginal(self, mol) def morph(self): return _core.AddBond_morph(self) def getName(self): return _core.AddBond_getName(self) def getOpenBonds(self): return _core.AddBond_getOpenBonds(self) __swig_destroy__ = _core.delete_AddBond __del__ = lambda self: None AddBond_swigregister = _core.AddBond_swigregister AddBond_swigregister(AddBond) class RemoveBond(MorphingOperator): __swig_setmethods__ = {} for _s in [MorphingOperator]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, RemoveBond, name, value) __swig_getmethods__ = {} for _s in [MorphingOperator]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, RemoveBond, name) __repr__ = _swig_repr def __init__(self): this = _core.new_RemoveBond() try: self.this.append(this) except __builtin__.Exception: self.this = this def setOriginal(self, mol): return _core.RemoveBond_setOriginal(self, mol) def morph(self): return _core.RemoveBond_morph(self) def getName(self): return _core.RemoveBond_getName(self) def getOpenBonds(self): return _core.RemoveBond_getOpenBonds(self) __swig_destroy__ = _core.delete_RemoveBond __del__ = lambda self: None RemoveBond_swigregister = _core.RemoveBond_swigregister RemoveBond_swigregister(RemoveBond) class ContractBond(MorphingOperator): __swig_setmethods__ = {} for _s in [MorphingOperator]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, ContractBond, name, value) __swig_getmethods__ = {} for _s in [MorphingOperator]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, ContractBond, name) __repr__ = _swig_repr def __init__(self): this = _core.new_ContractBond() try: self.this.append(this) except __builtin__.Exception: self.this = this def setOriginal(self, mol): return _core.ContractBond_setOriginal(self, mol) def morph(self): return _core.ContractBond_morph(self) def getName(self): return _core.ContractBond_getName(self) def getOpenBonds(self): return _core.ContractBond_getOpenBonds(self) __swig_destroy__ = _core.delete_ContractBond __del__ = lambda self: None ContractBond_swigregister = _core.ContractBond_swigregister ContractBond_swigregister(ContractBond) class InterlayAtom(MorphingOperator): __swig_setmethods__ = {} for _s in [MorphingOperator]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, InterlayAtom, name, value) __swig_getmethods__ = {} for _s in [MorphingOperator]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, InterlayAtom, name) __repr__ = _swig_repr def __init__(self, *args): this = _core.new_InterlayAtom(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def setOriginal(self, mol): return _core.InterlayAtom_setOriginal(self, mol) def morph(self): return _core.InterlayAtom_morph(self) def getName(self): return _core.InterlayAtom_getName(self) __swig_destroy__ = _core.delete_InterlayAtom __del__ = lambda self: None InterlayAtom_swigregister = _core.InterlayAtom_swigregister InterlayAtom_swigregister(InterlayAtom) class RerouteBond(MorphingOperator): __swig_setmethods__ = {} for _s in [MorphingOperator]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, RerouteBond, name, value) __swig_getmethods__ = {} for _s in [MorphingOperator]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, RerouteBond, name) __repr__ = _swig_repr def __init__(self): this = _core.new_RerouteBond() try: self.this.append(this) except __builtin__.Exception: self.this = this def setOriginal(self, mol): return _core.RerouteBond_setOriginal(self, mol) def morph(self): return _core.RerouteBond_morph(self) def getName(self): return _core.RerouteBond_getName(self) __swig_destroy__ = _core.delete_RerouteBond __del__ = lambda self: None RerouteBond_swigregister = _core.RerouteBond_swigregister RerouteBond_swigregister(RerouteBond) # This file is compatible with both classic and new-style classes.