base/__init__.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.2
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.





from sys import version_info
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('_IMP_base', [dirname(__file__)])
        except ImportError:
            import _IMP_base
            return _IMP_base
        if fp is not None:
            try:
                _mod = imp.load_module('_IMP_base', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _IMP_base = swig_import_helper()
    del swig_import_helper
else:
    import _IMP_base
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):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

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

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


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


class IMP_BASE_SwigPyIterator(_object):
    """Proxy of C++ swig::IMP_BASE_SwigPyIterator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IMP_BASE_SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IMP_BASE_SwigPyIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_base.delete_IMP_BASE_SwigPyIterator
    __del__ = lambda self : None;
    def value(self):
        """value(IMP_BASE_SwigPyIterator self) -> PyObject *"""
        return _IMP_base.IMP_BASE_SwigPyIterator_value(self)

    def incr(self, n=1):
        """
        incr(IMP_BASE_SwigPyIterator self, size_t n=1) -> IMP_BASE_SwigPyIterator
        incr(IMP_BASE_SwigPyIterator self) -> IMP_BASE_SwigPyIterator
        """
        return _IMP_base.IMP_BASE_SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        """
        decr(IMP_BASE_SwigPyIterator self, size_t n=1) -> IMP_BASE_SwigPyIterator
        decr(IMP_BASE_SwigPyIterator self) -> IMP_BASE_SwigPyIterator
        """
        return _IMP_base.IMP_BASE_SwigPyIterator_decr(self, n)

    def distance(self, *args):
        """distance(IMP_BASE_SwigPyIterator self, IMP_BASE_SwigPyIterator x) -> ptrdiff_t"""
        return _IMP_base.IMP_BASE_SwigPyIterator_distance(self, *args)

    def equal(self, *args):
        """equal(IMP_BASE_SwigPyIterator self, IMP_BASE_SwigPyIterator x) -> bool"""
        return _IMP_base.IMP_BASE_SwigPyIterator_equal(self, *args)

    def copy(self):
        """copy(IMP_BASE_SwigPyIterator self) -> IMP_BASE_SwigPyIterator"""
        return _IMP_base.IMP_BASE_SwigPyIterator_copy(self)

    def next(self):
        """next(IMP_BASE_SwigPyIterator self) -> PyObject *"""
        return _IMP_base.IMP_BASE_SwigPyIterator_next(self)

    def __next__(self):
        """__next__(IMP_BASE_SwigPyIterator self) -> PyObject *"""
        return _IMP_base.IMP_BASE_SwigPyIterator___next__(self)

    def previous(self):
        """previous(IMP_BASE_SwigPyIterator self) -> PyObject *"""
        return _IMP_base.IMP_BASE_SwigPyIterator_previous(self)

    def advance(self, *args):
        """advance(IMP_BASE_SwigPyIterator self, ptrdiff_t n) -> IMP_BASE_SwigPyIterator"""
        return _IMP_base.IMP_BASE_SwigPyIterator_advance(self, *args)

    def __eq__(self, *args):
        """__eq__(IMP_BASE_SwigPyIterator self, IMP_BASE_SwigPyIterator x) -> bool"""
        return _IMP_base.IMP_BASE_SwigPyIterator___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(IMP_BASE_SwigPyIterator self, IMP_BASE_SwigPyIterator x) -> bool"""
        return _IMP_base.IMP_BASE_SwigPyIterator___ne__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(IMP_BASE_SwigPyIterator self, ptrdiff_t n) -> IMP_BASE_SwigPyIterator"""
        return _IMP_base.IMP_BASE_SwigPyIterator___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(IMP_BASE_SwigPyIterator self, ptrdiff_t n) -> IMP_BASE_SwigPyIterator"""
        return _IMP_base.IMP_BASE_SwigPyIterator___isub__(self, *args)

    def __add__(self, *args):
        """__add__(IMP_BASE_SwigPyIterator self, ptrdiff_t n) -> IMP_BASE_SwigPyIterator"""
        return _IMP_base.IMP_BASE_SwigPyIterator___add__(self, *args)

    def __sub__(self, *args):
        """
        __sub__(IMP_BASE_SwigPyIterator self, ptrdiff_t n) -> IMP_BASE_SwigPyIterator
        __sub__(IMP_BASE_SwigPyIterator self, IMP_BASE_SwigPyIterator x) -> ptrdiff_t
        """
        return _IMP_base.IMP_BASE_SwigPyIterator___sub__(self, *args)

    def __iter__(self): return self
IMP_BASE_SwigPyIterator_swigregister = _IMP_base.IMP_BASE_SwigPyIterator_swigregister
IMP_BASE_SwigPyIterator_swigregister(IMP_BASE_SwigPyIterator)

_value_types=[]
_object_types=[]
_raii_types=[]
_plural_types=[]

IMP_DEBUG = _IMP_base.IMP_DEBUG
IMP_RELEASE = _IMP_base.IMP_RELEASE
IMP_SILENT = _IMP_base.IMP_SILENT
IMP_PROGRESS = _IMP_base.IMP_PROGRESS
IMP_TERSE = _IMP_base.IMP_TERSE
IMP_VERBOSE = _IMP_base.IMP_VERBOSE
IMP_MEMORY = _IMP_base.IMP_MEMORY
IMP_NONE = _IMP_base.IMP_NONE
IMP_USAGE = _IMP_base.IMP_USAGE
IMP_INTERNAL = _IMP_base.IMP_INTERNAL
IMP_BASE_HAS_LOG4CXX = _IMP_base.IMP_BASE_HAS_LOG4CXX
IMP_COMPILER_HAS_AUTO = _IMP_base.IMP_COMPILER_HAS_AUTO
IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_base.IMP_COMPILER_HAS_DEBUG_VECTOR
IMP_BASE_HAS_BOOST_RANDOM = _IMP_base.IMP_BASE_HAS_BOOST_RANDOM
IMP_BASE_HAS_GPERFTOOLS = _IMP_base.IMP_BASE_HAS_GPERFTOOLS
IMP_BASE_HAS_TCMALLOC_HEAPCHECKER = _IMP_base.IMP_BASE_HAS_TCMALLOC_HEAPCHECKER
IMP_BASE_HAS_TCMALLOC_HEAPPROFILER = _IMP_base.IMP_BASE_HAS_TCMALLOC_HEAPPROFILER
IMPBASE_SHOW_WARNINGS = _IMP_base.IMPBASE_SHOW_WARNINGS
import sys
class _DirectorObjects(object):
    """@internal Simple class to keep references to director objects
       to prevent premature deletion."""
    def __init__(self):
        self._objects = []
    def register(self, obj):
        """Take a reference to a director object; will only work for
           refcounted C++ classes"""
        if hasattr(obj, 'get_ref_count'):
            self._objects.append(obj)
    def cleanup(self):
        """Only drop our reference and allow cleanup by Python if no other
           Python references exist (we hold 3 references: one in self._objects,
           one in x, and one in the argument list for getrefcount) *and* no
           other C++ references exist (the Python object always holds one)"""
        objs = [x for x in self._objects if sys.getrefcount(x) > 3 \
                                         or x.get_ref_count() > 1]
        
        
        self._objects = objs
    def get_object_count(self):
        """Get number of director objects (useful for testing only)"""
        return len(self._objects)
_director_objects = _DirectorObjects()

DEFAULT_CHECK = _IMP_base.DEFAULT_CHECK
NONE = _IMP_base.NONE
USAGE = _IMP_base.USAGE
USAGE_AND_INTERNAL = _IMP_base.USAGE_AND_INTERNAL

def set_check_level(*args):
  """set_check_level(IMP::base::CheckLevel tf)"""
  return _IMP_base.set_check_level(*args)

def get_check_level():
  """get_check_level() -> IMP::base::CheckLevel"""
  return _IMP_base.get_check_level()
from _IMP_base import Exception, InternalException, ModelException, EventException
from _IMP_base import UsageException, IndexException, IOException, ValueException

import sys
if sys.version_info[:2] < (2,5):
    IndexException.__bases__ += (IndexError,)
    IOException.__bases__ += (IOError,)
    ValueException.__bases__ += (ValueError,)

class _ostream(_object):
    """Proxy of C++ std::ostream class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _ostream, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _ostream, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def write(self, *args):
        """write(_ostream self, char const * osa_buf)"""
        return _IMP_base._ostream_write(self, *args)

_ostream_swigregister = _IMP_base._ostream_swigregister
_ostream_swigregister(_ostream)

IMP_COMPILER_HAS_OVERRIDE = _IMP_base.IMP_COMPILER_HAS_OVERRIDE
IMP_COMPILER_HAS_FINAL = _IMP_base.IMP_COMPILER_HAS_FINAL
IMP_HAS_NOEXCEPT = _IMP_base.IMP_HAS_NOEXCEPT
class RandomNumberGenerator(_object):
    """Proxy of C++ IMP::base::RandomNumberGenerator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RandomNumberGenerator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RandomNumberGenerator, name)
    __repr__ = _swig_repr
    def seed(self, *args):
        """seed(RandomNumberGenerator self, ::boost::int32_t x)"""
        return _IMP_base.RandomNumberGenerator_seed(self, *args)

    def __call__(self):
        """__call__(RandomNumberGenerator self) -> int"""
        return _IMP_base.RandomNumberGenerator___call__(self)

    def __init__(self): 
        """__init__(IMP::base::RandomNumberGenerator self) -> RandomNumberGenerator"""
        this = _IMP_base.new_RandomNumberGenerator()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_base.delete_RandomNumberGenerator
    __del__ = lambda self : None;
RandomNumberGenerator_swigregister = _IMP_base.RandomNumberGenerator_swigregister
RandomNumberGenerator_swigregister(RandomNumberGenerator)

_raii_types.append("SetLogState")

_raii_types.append("SetNumberOfThreads")

_raii_types.append("SetCheckState")

_object_types.append("Object")


def _object_cast_to_Object(*args):
  """_object_cast_to_Object(Object * o) -> Object"""
  return _IMP_base._object_cast_to_Object(*args)
_object_types.append("_TestObject")


def _object_cast_to__TestObject(*args):
  """_object_cast_to__TestObject(Object * o) -> _TestObject"""
  return _IMP_base._object_cast_to__TestObject(*args)
VersionInfos=list
_plural_types.append("VersionInfos")
_value_types.append("VersionInfo")

_raii_types.append("CreateLogContext")

_raii_types.append("WarningContext")

_raii_types.append("SetLogTarget")

_TestValues=list
_plural_types.append("_TestValues")
_value_types.append("_TestValue")

Floats=list
_plural_types.append("Floats")
_value_types.append("Float")

Ints=list
_plural_types.append("Ints")
_value_types.append("Int")

Strings=list
_plural_types.append("Strings")
_value_types.append("String")

_Protections=list
_plural_types.append("_Protections")
_value_types.append("_Protection")

class _InputAdaptor(_object):
    """Proxy of C++ IMP::base::InputAdaptor class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _InputAdaptor, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _InputAdaptor, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_base.delete__InputAdaptor
    __del__ = lambda self : None;
_InputAdaptor_swigregister = _IMP_base._InputAdaptor_swigregister
_InputAdaptor_swigregister(_InputAdaptor)
cvar = _IMP_base.cvar
random_number_generator = cvar.random_number_generator

class _NonCopyable(_object):
    """Proxy of C++ IMP::base::NonCopyable class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _NonCopyable, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _NonCopyable, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_base.delete__NonCopyable
    __del__ = lambda self : None;
_NonCopyable_swigregister = _IMP_base._NonCopyable_swigregister
_NonCopyable_swigregister(_NonCopyable)

class _RAII(_NonCopyable):
    """Proxy of C++ IMP::base::RAII class"""
    __swig_setmethods__ = {}
    for _s in [_NonCopyable]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _RAII, name, value)
    __swig_getmethods__ = {}
    for _s in [_NonCopyable]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _RAII, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_base.delete__RAII
    __del__ = lambda self : None;
_RAII_swigregister = _IMP_base._RAII_swigregister
_RAII_swigregister(_RAII)

class _Value(_object):
    """Proxy of C++ IMP::base::Value class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _Value, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _Value, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_base.delete__Value
    __del__ = lambda self : None;
_Value_swigregister = _IMP_base._Value_swigregister
_Value_swigregister(_Value)


def get_executable_name():
  """get_executable_name() -> std::string"""
  return _IMP_base.get_executable_name()

def setup_from_argv(*args):
  """
    setup_from_argv(IMP::Strings const & argv, std::string description)
    setup_from_argv(IMP::Strings const & argv, std::string description, std::string positional_description, 
        int num_positional) -> IMP::Strings
    """
  return _IMP_base.setup_from_argv(*args)

def add_string_flag(*args):
  """add_string_flag(std::string name, std::string default_value, std::string description)"""
  return _IMP_base.add_string_flag(*args)

def get_string_flag(*args):
  """get_string_flag(std::string name) -> std::string"""
  return _IMP_base.get_string_flag(*args)

def add_int_flag(*args):
  """add_int_flag(std::string name, size_t default_value, std::string description)"""
  return _IMP_base.add_int_flag(*args)

def get_int_flag(*args):
  """get_int_flag(std::string name) -> size_t"""
  return _IMP_base.get_int_flag(*args)

def add_bool_flag(*args):
  """add_bool_flag(std::string name, std::string description)"""
  return _IMP_base.add_bool_flag(*args)

def get_bool_flag(*args):
  """get_bool_flag(std::string name) -> bool"""
  return _IMP_base.get_bool_flag(*args)

def add_float_flag(*args):
  """add_float_flag(std::string name, double default_value, std::string description)"""
  return _IMP_base.add_float_flag(*args)

def get_float_flag(*args):
  """get_float_flag(std::string name) -> double"""
  return _IMP_base.get_float_flag(*args)

def write_help(*args):
  """
    write_help(_ostream out=std::cerr)
    write_help()
    """
  return _IMP_base.write_help(*args)

def get_is_quick_test():
  """get_is_quick_test() -> bool"""
  return _IMP_base.get_is_quick_test()
DEFAULT = _IMP_base.DEFAULT
SILENT = _IMP_base.SILENT
WARNING = _IMP_base.WARNING
PROGRESS = _IMP_base.PROGRESS
TERSE = _IMP_base.TERSE
VERBOSE = _IMP_base.VERBOSE
MEMORY = _IMP_base.MEMORY
ALL_LOG = _IMP_base.ALL_LOG
NO_STATISTICS = _IMP_base.NO_STATISTICS
ALL_STATISTICS = _IMP_base.ALL_STATISTICS
class VersionInfo(_Value):
    """Proxy of C++ IMP::base::VersionInfo class"""
    __swig_setmethods__ = {}
    for _s in [_Value]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, VersionInfo, name, value)
    __swig_getmethods__ = {}
    for _s in [_Value]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, VersionInfo, name)
    def __init__(self, *args): 
        """
        __init__(IMP::base::VersionInfo self, std::string module, std::string version) -> VersionInfo
        __init__(IMP::base::VersionInfo self) -> VersionInfo
        """
        this = _IMP_base.new_VersionInfo(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_module(self):
        """get_module(VersionInfo self) -> std::string"""
        return _IMP_base.VersionInfo_get_module(self)

    def get_version(self):
        """get_version(VersionInfo self) -> std::string"""
        return _IMP_base.VersionInfo_get_version(self)

    def show(self, *args):
        """
        show(VersionInfo self, _ostream out=std::cout)
        show(VersionInfo self)
        """
        return _IMP_base.VersionInfo_show(self, *args)

    def __eq__(self, *args):
        """__eq__(VersionInfo self, VersionInfo o) -> bool"""
        return _IMP_base.VersionInfo___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(VersionInfo self, VersionInfo o) -> bool"""
        return _IMP_base.VersionInfo___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(VersionInfo self, VersionInfo o) -> bool"""
        return _IMP_base.VersionInfo___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(VersionInfo self, VersionInfo o) -> bool"""
        return _IMP_base.VersionInfo___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(VersionInfo self, VersionInfo o) -> bool"""
        return _IMP_base.VersionInfo___ge__(self, *args)

    def __le__(self, *args):
        """__le__(VersionInfo self, VersionInfo o) -> bool"""
        return _IMP_base.VersionInfo___le__(self, *args)

    def __str__(self):
        """__str__(VersionInfo self) -> std::string"""
        return _IMP_base.VersionInfo___str__(self)

    def __repr__(self):
        """__repr__(VersionInfo self) -> std::string"""
        return _IMP_base.VersionInfo___repr__(self)

    __swig_destroy__ = _IMP_base.delete_VersionInfo
    __del__ = lambda self : None;
VersionInfo_swigregister = _IMP_base.VersionInfo_swigregister
VersionInfo_swigregister(VersionInfo)

class TextOutput(_InputAdaptor):
    """Proxy of C++ IMP::base::TextOutput class"""
    __swig_setmethods__ = {}
    for _s in [_InputAdaptor]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TextOutput, name, value)
    __swig_getmethods__ = {}
    for _s in [_InputAdaptor]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TextOutput, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(IMP::base::TextOutput self, int arg2) -> TextOutput
        __init__(IMP::base::TextOutput self, double arg2) -> TextOutput
        __init__(IMP::base::TextOutput self, char const * c, bool append=False) -> TextOutput
        __init__(IMP::base::TextOutput self, char const * c) -> TextOutput
        __init__(IMP::base::TextOutput self, IMP::base::TextProxy< std::ostream > p) -> TextOutput
        __init__(IMP::base::TextOutput self) -> TextOutput
        __init__(IMP::base::TextOutput self, std::string file_name, bool append=False) -> TextOutput
        __init__(IMP::base::TextOutput self, std::string file_name) -> TextOutput
        """
        this = _IMP_base.new_TextOutput(*args)
        try: self.this.append(this)
        except: self.this = this
    def show(self, *args):
        """
        show(TextOutput self, _ostream out=std::cout)
        show(TextOutput self)
        """
        return _IMP_base.TextOutput_show(self, *args)

    def get_name(self):
        """get_name(TextOutput self) -> std::string"""
        return _IMP_base.TextOutput_get_name(self)

    __swig_destroy__ = _IMP_base.delete_TextOutput
    __del__ = lambda self : None;
TextOutput_swigregister = _IMP_base.TextOutput_swigregister
TextOutput_swigregister(TextOutput)

class TextInput(_InputAdaptor):
    """Proxy of C++ IMP::base::TextInput class"""
    __swig_setmethods__ = {}
    for _s in [_InputAdaptor]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TextInput, name, value)
    __swig_getmethods__ = {}
    for _s in [_InputAdaptor]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TextInput, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(IMP::base::TextInput self, int arg2) -> TextInput
        __init__(IMP::base::TextInput self, double arg2) -> TextInput
        __init__(IMP::base::TextInput self, char const * c) -> TextInput
        __init__(IMP::base::TextInput self, IMP::base::TextProxy< std::istream > p) -> TextInput
        __init__(IMP::base::TextInput self) -> TextInput
        __init__(IMP::base::TextInput self, std::string file_name) -> TextInput
        """
        this = _IMP_base.new_TextInput(*args)
        try: self.this.append(this)
        except: self.this = this
    def show(self, *args):
        """
        show(TextInput self, _ostream out=std::cout)
        show(TextInput self)
        """
        return _IMP_base.TextInput_show(self, *args)

    def get_name(self):
        """get_name(TextInput self) -> std::string"""
        return _IMP_base.TextInput_get_name(self)

    __swig_destroy__ = _IMP_base.delete_TextInput
    __del__ = lambda self : None;
TextInput_swigregister = _IMP_base.TextInput_swigregister
TextInput_swigregister(TextInput)

class SetLogTarget(_RAII):
    """Proxy of C++ IMP::base::SetLogTarget class"""
    __swig_setmethods__ = {}
    for _s in [_RAII]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SetLogTarget, name, value)
    __swig_getmethods__ = {}
    for _s in [_RAII]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SetLogTarget, name)
    def __init__(self, *args): 
        """
        __init__(IMP::base::SetLogTarget self) -> SetLogTarget
        __init__(IMP::base::SetLogTarget self, TextOutput to) -> SetLogTarget
        """
        this = _IMP_base.new_SetLogTarget(*args)
        try: self.this.append(this)
        except: self.this = this
    def set(self, *args):
        """set(SetLogTarget self, TextOutput to)"""
        return _IMP_base.SetLogTarget_set(self, *args)

    def reset(self):
        """reset(SetLogTarget self)"""
        return _IMP_base.SetLogTarget_reset(self)

    __swig_destroy__ = _IMP_base.delete_SetLogTarget
    __del__ = lambda self : None;
    def show(self, *args):
        """
        show(SetLogTarget self, _ostream out=std::cout)
        show(SetLogTarget self)
        """
        return _IMP_base.SetLogTarget_show(self, *args)

    def __str__(self):
        """__str__(SetLogTarget self) -> std::string"""
        return _IMP_base.SetLogTarget___str__(self)

    def __repr__(self):
        """__repr__(SetLogTarget self) -> std::string"""
        return _IMP_base.SetLogTarget___repr__(self)

SetLogTarget_swigregister = _IMP_base.SetLogTarget_swigregister
SetLogTarget_swigregister(SetLogTarget)


def create_temporary_file(prefix="imp_temp", suffix=""):
  """
    create_temporary_file(std::string prefix="imp_temp", std::string suffix="") -> TextOutput
    create_temporary_file(std::string prefix="imp_temp") -> TextOutput
    create_temporary_file() -> TextOutput
    """
  return _IMP_base.create_temporary_file(prefix, suffix)

def create_temporary_file_name(prefix="imp_temp", suffix=""):
  """
    create_temporary_file_name(std::string prefix="imp_temp", std::string suffix="") -> std::string
    create_temporary_file_name(std::string prefix="imp_temp") -> std::string
    create_temporary_file_name() -> std::string
    """
  return _IMP_base.create_temporary_file_name(prefix, suffix)

def get_relative_path(*args):
  """get_relative_path(std::string base, std::string relative) -> std::string"""
  return _IMP_base.get_relative_path(*args)

def push_log_context(*args):
  """push_log_context(char const * functionname, void const * object)"""
  return _IMP_base.push_log_context(*args)

def pop_log_context():
  """pop_log_context()"""
  return _IMP_base.pop_log_context()

def add_to_log(*args):
  """
    add_to_log(std::string to_write)
    add_to_log(IMP::base::LogLevel level, std::string to_write)
    """
  return _IMP_base.add_to_log(*args)

def set_log_level(*args):
  """set_log_level(IMP::base::LogLevel l)"""
  return _IMP_base.set_log_level(*args)

def set_log_timer(*args):
  """set_log_timer(bool tb)"""
  return _IMP_base.set_log_timer(*args)

def reset_log_timer():
  """reset_log_timer()"""
  return _IMP_base.reset_log_timer()

def get_log_level():
  """get_log_level() -> IMP::base::LogLevel"""
  return _IMP_base.get_log_level()

def set_progress_display(*args):
  """set_progress_display(std::string description, unsigned int steps)"""
  return _IMP_base.set_progress_display(*args)

def add_to_progress_display(step=1):
  """
    add_to_progress_display(unsigned int step=1)
    add_to_progress_display()
    """
  return _IMP_base.add_to_progress_display(step)
class Object(_NonCopyable):
    """Proxy of C++ IMP::base::Object class"""
    __swig_setmethods__ = {}
    for _s in [_NonCopyable]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Object, name, value)
    __swig_getmethods__ = {}
    for _s in [_NonCopyable]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Object, name)
    def __init__(self, *args): 
        """__init__(IMP::base::Object self, std::string name) -> Object"""
        if self.__class__ == Object:
            _self = None
        else:
            _self = self
        this = _IMP_base.new_Object(_self, *args)
        try: self.this.append(this)
        except: self.this = this
        if self.__class__ != Object:
            import IMP.base
            IMP.base._director_objects.register(self)



    __swig_destroy__ = _IMP_base.delete_Object
    __del__ = lambda self : None;
    def __hash__(self):
        """__hash__(Object self) -> std::size_t"""
        return _IMP_base.Object___hash__(self)

    def set_log_level(self, *args):
        """set_log_level(Object self, IMP::base::LogLevel l)"""
        return _IMP_base.Object_set_log_level(self, *args)

    def set_check_level(self, *args):
        """set_check_level(Object self, IMP::base::CheckLevel l)"""
        return _IMP_base.Object_set_check_level(self, *args)

    def get_log_level(self):
        """get_log_level(Object self) -> IMP::base::LogLevel"""
        return _IMP_base.Object_get_log_level(self)

    def get_check_level(self):
        """get_check_level(Object self) -> IMP::base::CheckLevel"""
        return _IMP_base.Object_get_check_level(self)

    def get_version_info(self):
        """get_version_info(Object self) -> VersionInfo"""
        return _IMP_base.Object_get_version_info(self)

    def get_name(self):
        """get_name(Object self) -> std::string const &"""
        return _IMP_base.Object_get_name(self)

    def set_name(self, *args):
        """set_name(Object self, std::string name)"""
        return _IMP_base.Object_set_name(self, *args)

    def get_type_name(self):
        """get_type_name(Object self) -> std::string"""
        return _IMP_base.Object_get_type_name(self)

    def set_was_used(self, *args):
        """set_was_used(Object self, bool tf)"""
        return _IMP_base.Object_set_was_used(self, *args)

    def show(self, *args):
        """
        show(Object self, _ostream out=std::cout)
        show(Object self)
        """
        return _IMP_base.Object_show(self, *args)

    def get_string(self):
        """get_string(Object self) -> std::string"""
        return _IMP_base.Object_get_string(self)

    def _on_destruction(self):
        """_on_destruction(Object self)"""
        return _IMP_base.Object__on_destruction(self)

    def get_is_valid(self):
        """get_is_valid(Object self) -> bool"""
        return _IMP_base.Object_get_is_valid(self)

    def get_ref_count(self):
        """get_ref_count(Object self) -> unsigned int"""
        return _IMP_base.Object_get_ref_count(self)

    def get_number_of_live_objects():
        """get_number_of_live_objects() -> unsigned int"""
        return _IMP_base.Object_get_number_of_live_objects()

    if _newclass:get_number_of_live_objects = staticmethod(get_number_of_live_objects)
    __swig_getmethods__["get_number_of_live_objects"] = lambda x: get_number_of_live_objects
    def get_is_shared(self):
        """get_is_shared(Object self) -> bool"""
        return _IMP_base.Object_get_is_shared(self)

    def clear_caches(self):
        """clear_caches(Object self)"""
        return _IMP_base.Object_clear_caches(self)

    def do_destroy(self):
        """do_destroy(Object self)"""
        return _IMP_base.Object_do_destroy(self)

    def __eq__(self, *args):
        """__eq__(Object self, Object o) -> bool"""
        return _IMP_base.Object___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(Object self, Object o) -> bool"""
        return _IMP_base.Object___ne__(self, *args)

    def __le__(self, *args):
        """__le__(Object self, Object o) -> bool"""
        return _IMP_base.Object___le__(self, *args)

    def __lt__(self, *args):
        """__lt__(Object self, Object o) -> bool"""
        return _IMP_base.Object___lt__(self, *args)

    def __ge__(self, *args):
        """__ge__(Object self, Object o) -> bool"""
        return _IMP_base.Object___ge__(self, *args)

    def __gt__(self, *args):
        """__gt__(Object self, Object o) -> bool"""
        return _IMP_base.Object___gt__(self, *args)

    def __str__(self):
        """__str__(Object self) -> std::string"""
        return _IMP_base.Object___str__(self)

    def __repr__(self):
        """__repr__(Object self) -> std::string"""
        return _IMP_base.Object___repr__(self)

    def get_from(o):
       return _object_cast_to_Object(o)
    get_from = staticmethod(get_from)

    def __disown__(self):
        self.this.disown()
        _IMP_base.disown_Object(self)
        return weakref_proxy(self)
Object_swigregister = _IMP_base.Object_swigregister
Object_swigregister(Object)

def Object_get_number_of_live_objects():
  """Object_get_number_of_live_objects() -> unsigned int"""
  return _IMP_base.Object_get_number_of_live_objects()

class SetLogState(_RAII):
    """Proxy of C++ IMP::base::SetLogState class"""
    __swig_setmethods__ = {}
    for _s in [_RAII]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SetLogState, name, value)
    __swig_getmethods__ = {}
    for _s in [_RAII]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SetLogState, name)
    def reset(self):
        """reset(SetLogState self)"""
        return _IMP_base.SetLogState_reset(self)

    __swig_destroy__ = _IMP_base.delete_SetLogState
    __del__ = lambda self : None;
    def show(self, *args):
        """
        show(SetLogState self, _ostream out=std::cout)
        show(SetLogState self)
        """
        return _IMP_base.SetLogState_show(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::base::SetLogState self) -> SetLogState
        __init__(IMP::base::SetLogState self, Object o, IMP::base::LogLevel l) -> SetLogState
        __init__(IMP::base::SetLogState self, IMP::base::LogLevel l) -> SetLogState
        """
        this = _IMP_base.new_SetLogState(*args)
        try: self.this.append(this)
        except: self.this = this
    def set(self, *args):
        """
        set(SetLogState self, Object o, IMP::base::LogLevel l)
        set(SetLogState self, IMP::base::LogLevel l)
        """
        return _IMP_base.SetLogState_set(self, *args)

    def __str__(self):
        """__str__(SetLogState self) -> std::string"""
        return _IMP_base.SetLogState___str__(self)

    def __repr__(self):
        """__repr__(SetLogState self) -> std::string"""
        return _IMP_base.SetLogState___repr__(self)

SetLogState_swigregister = _IMP_base.SetLogState_swigregister
SetLogState_swigregister(SetLogState)

class WarningContext(_object):
    """Proxy of C++ IMP::base::WarningContext class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WarningContext, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WarningContext, name)
    __swig_setmethods__["data_"] = _IMP_base.WarningContext_data__set
    __swig_getmethods__["data_"] = _IMP_base.WarningContext_data__get
    if _newclass:data_ = _swig_property(_IMP_base.WarningContext_data__get, _IMP_base.WarningContext_data__set)
    def add_warning(self, *args):
        """add_warning(WarningContext self, std::string key, std::string warning)"""
        return _IMP_base.WarningContext_add_warning(self, *args)

    def clear_warnings(self):
        """clear_warnings(WarningContext self)"""
        return _IMP_base.WarningContext_clear_warnings(self)

    def dump_warnings(self):
        """dump_warnings(WarningContext self)"""
        return _IMP_base.WarningContext_dump_warnings(self)

    __swig_destroy__ = _IMP_base.delete_WarningContext
    __del__ = lambda self : None;
    def show(self, *args):
        """
        show(WarningContext self, _ostream out=std::cout)
        show(WarningContext self)
        """
        return _IMP_base.WarningContext_show(self, *args)

    def __str__(self):
        """__str__(WarningContext self) -> std::string"""
        return _IMP_base.WarningContext___str__(self)

    def __repr__(self):
        """__repr__(WarningContext self) -> std::string"""
        return _IMP_base.WarningContext___repr__(self)

    def __init__(self): 
        """__init__(IMP::base::WarningContext self) -> WarningContext"""
        this = _IMP_base.new_WarningContext()
        try: self.this.append(this)
        except: self.this = this
WarningContext_swigregister = _IMP_base.WarningContext_swigregister
WarningContext_swigregister(WarningContext)

class CreateLogContext(_RAII):
    """Proxy of C++ IMP::base::CreateLogContext class"""
    __swig_setmethods__ = {}
    for _s in [_RAII]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CreateLogContext, name, value)
    __swig_getmethods__ = {}
    for _s in [_RAII]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CreateLogContext, name)
    def __init__(self, *args): 
        """
        __init__(IMP::base::CreateLogContext self, std::string fname, Object object=None) -> CreateLogContext
        __init__(IMP::base::CreateLogContext self, std::string fname) -> CreateLogContext
        __init__(IMP::base::CreateLogContext self) -> CreateLogContext
        __init__(IMP::base::CreateLogContext self, char const * fname, Object object=None) -> CreateLogContext
        __init__(IMP::base::CreateLogContext self, char const * fname) -> CreateLogContext
        """
        this = _IMP_base.new_CreateLogContext(*args)
        try: self.this.append(this)
        except: self.this = this
    def set(self, *args):
        """
        set(CreateLogContext self, char const * fname, Object object=None)
        set(CreateLogContext self, char const * fname)
        """
        return _IMP_base.CreateLogContext_set(self, *args)

    def reset(self):
        """reset(CreateLogContext self)"""
        return _IMP_base.CreateLogContext_reset(self)

    __swig_destroy__ = _IMP_base.delete_CreateLogContext
    __del__ = lambda self : None;
    def show(self, *args):
        """
        show(CreateLogContext self, _ostream out=std::cout)
        show(CreateLogContext self)
        """
        return _IMP_base.CreateLogContext_show(self, *args)

    def __str__(self):
        """__str__(CreateLogContext self) -> std::string"""
        return _IMP_base.CreateLogContext___str__(self)

    def __repr__(self):
        """__repr__(CreateLogContext self) -> std::string"""
        return _IMP_base.CreateLogContext___repr__(self)

CreateLogContext_swigregister = _IMP_base.CreateLogContext_swigregister
CreateLogContext_swigregister(CreateLogContext)

class SetCheckState(_RAII):
    """Proxy of C++ IMP::base::SetCheckState class"""
    __swig_setmethods__ = {}
    for _s in [_RAII]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SetCheckState, name, value)
    __swig_getmethods__ = {}
    for _s in [_RAII]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SetCheckState, name)
    def reset(self):
        """reset(SetCheckState self)"""
        return _IMP_base.SetCheckState_reset(self)

    __swig_destroy__ = _IMP_base.delete_SetCheckState
    __del__ = lambda self : None;
    def show(self, *args):
        """
        show(SetCheckState self, _ostream out=std::cout)
        show(SetCheckState self)
        """
        return _IMP_base.SetCheckState_show(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::base::SetCheckState self) -> SetCheckState
        __init__(IMP::base::SetCheckState self, Object o, IMP::base::CheckLevel l) -> SetCheckState
        __init__(IMP::base::SetCheckState self, IMP::base::CheckLevel l) -> SetCheckState
        """
        this = _IMP_base.new_SetCheckState(*args)
        try: self.this.append(this)
        except: self.this = this
    def set(self, *args):
        """
        set(SetCheckState self, Object o, IMP::base::CheckLevel l)
        set(SetCheckState self, IMP::base::CheckLevel l)
        """
        return _IMP_base.SetCheckState_set(self, *args)

    def __str__(self):
        """__str__(SetCheckState self) -> std::string"""
        return _IMP_base.SetCheckState___str__(self)

    def __repr__(self):
        """__repr__(SetCheckState self) -> std::string"""
        return _IMP_base.SetCheckState___repr__(self)

SetCheckState_swigregister = _IMP_base.SetCheckState_swigregister
SetCheckState_swigregister(SetCheckState)


def get_unique_name(*args):
  """get_unique_name(std::string templ) -> std::string"""
  return _IMP_base.get_unique_name(*args)
class _Protection(_object):
    """Proxy of C++ IMP::base::internal::_Protection class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _Protection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _Protection, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    def show(self, *args):
        """
        show(_Protection self, _ostream out=std::cout)
        show(_Protection self)
        """
        return _IMP_base._Protection_show(self, *args)

    def __str__(self):
        """__str__(_Protection self) -> std::string"""
        return _IMP_base._Protection___str__(self)

    def __repr__(self):
        """__repr__(_Protection self) -> std::string"""
        return _IMP_base._Protection___repr__(self)

    __swig_destroy__ = _IMP_base.delete__Protection
    __del__ = lambda self : None;
_Protection_swigregister = _IMP_base._Protection_swigregister
_Protection_swigregister(_Protection)


def _test_log():
  """_test_log()"""
  return _IMP_base._test_log()

def _test_intranges(*args):
  """_test_intranges(IMP::IntRanges const & ips) -> int"""
  return _IMP_base._test_intranges(*args)

def _test_intrange(*args):
  """
    _test_intrange(IMP::IntRange const & ips) -> IMP::IntRange
    _test_intrange() -> IMP::IntRange
    """
  return _IMP_base._test_intrange(*args)

def _test_ifile(*args):
  """_test_ifile(TextInput a) -> std::string"""
  return _IMP_base._test_ifile(*args)

def _test_ofile(*args):
  """_test_ofile(TextOutput a) -> std::string"""
  return _IMP_base._test_ofile(*args)

def _test_ifile_overloaded(*args):
  """
    _test_ifile_overloaded(TextInput a, int i) -> std::string
    _test_ifile_overloaded(TextInput a, std::string st) -> std::string
    """
  return _IMP_base._test_ifile_overloaded(*args)

def _test_ofile_overloaded(*args):
  """
    _test_ofile_overloaded(TextOutput a, int i) -> std::string
    _test_ofile_overloaded(TextOutput a, std::string st) -> std::string
    """
  return _IMP_base._test_ofile_overloaded(*args)
class _TestValue(_object):
    """Proxy of C++ IMP::base::internal::_TestValue class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, _TestValue, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, _TestValue, name)
    def __init__(self, *args): 
        """__init__(IMP::base::internal::_TestValue self, int i) -> _TestValue"""
        this = _IMP_base.new__TestValue(*args)
        try: self.this.append(this)
        except: self.this = this
    def show(self, *args):
        """
        show(_TestValue self, _ostream out=std::cout)
        show(_TestValue self)
        """
        return _IMP_base._TestValue_show(self, *args)

    def __eq__(self, *args):
        """__eq__(_TestValue self, _TestValue o) -> bool"""
        return _IMP_base._TestValue___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(_TestValue self, _TestValue o) -> bool"""
        return _IMP_base._TestValue___ne__(self, *args)

    def __lt__(self, *args):
        """__lt__(_TestValue self, _TestValue o) -> bool"""
        return _IMP_base._TestValue___lt__(self, *args)

    def __gt__(self, *args):
        """__gt__(_TestValue self, _TestValue o) -> bool"""
        return _IMP_base._TestValue___gt__(self, *args)

    def __ge__(self, *args):
        """__ge__(_TestValue self, _TestValue o) -> bool"""
        return _IMP_base._TestValue___ge__(self, *args)

    def __le__(self, *args):
        """__le__(_TestValue self, _TestValue o) -> bool"""
        return _IMP_base._TestValue___le__(self, *args)

    def get(self):
        """get(_TestValue self) -> int"""
        return _IMP_base._TestValue_get(self)

    def get_float(self):
        """get_float(_TestValue self) -> IMP::Float const &"""
        return _IMP_base._TestValue_get_float(self)

    def __str__(self):
        """__str__(_TestValue self) -> std::string"""
        return _IMP_base._TestValue___str__(self)

    def __repr__(self):
        """__repr__(_TestValue self) -> std::string"""
        return _IMP_base._TestValue___repr__(self)

    __swig_destroy__ = _IMP_base.delete__TestValue
    __del__ = lambda self : None;
_TestValue_swigregister = _IMP_base._TestValue_swigregister
_TestValue_swigregister(_TestValue)


def _pass_plain_pair(*args):
  """_pass_plain_pair(IMP::FloatPair p) -> IMP::FloatPair"""
  return _IMP_base._pass_plain_pair(*args)

def _pass_overloaded_strings(*args):
  """
    _pass_overloaded_strings(IMP::Strings const & a, int arg2) -> IMP::Strings
    _pass_overloaded_strings(IMP::Strings const & a) -> IMP::Strings
    """
  return _IMP_base._pass_overloaded_strings(*args)

def _pass_pair(*args):
  """_pass_pair(IMP::DerivativePair const & p) -> IMP::DerivativePair"""
  return _IMP_base._pass_pair(*args)

def _pass_floats(*args):
  """_pass_floats(IMP::Floats const & input) -> IMP::Floats"""
  return _IMP_base._pass_floats(*args)

def _pass_ints(*args):
  """_pass_ints(IMP::Ints input) -> IMP::Ints"""
  return _IMP_base._pass_ints(*args)

def _pass_ints_list(*args):
  """_pass_ints_list(IMP::IntsList const & input) -> IMP::IntsList"""
  return _IMP_base._pass_ints_list(*args)

def _pass_ints_lists(*args):
  """_pass_ints_lists(IMP::IntsLists const & input) -> IMP::IntsLists"""
  return _IMP_base._pass_ints_lists(*args)

def _pass_strings(*args):
  """_pass_strings(IMP::Strings const & input) -> IMP::Strings const &"""
  return _IMP_base._pass_strings(*args)
class _TestObject(Object):
    """Proxy of C++ IMP::base::internal::_TestObject class"""
    __swig_setmethods__ = {}
    for _s in [Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, _TestObject, name, value)
    __swig_getmethods__ = {}
    for _s in [Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, _TestObject, name)
    def __init__(self): 
        """__init__(IMP::base::internal::_TestObject self) -> _TestObject"""
        this = _IMP_base.new__TestObject()
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(_TestObject self) -> VersionInfo"""
        return _IMP_base._TestObject_get_version_info(self)

    def __str__(self):
        """__str__(_TestObject self) -> std::string"""
        return _IMP_base._TestObject___str__(self)

    def __repr__(self):
        """__repr__(_TestObject self) -> std::string"""
        return _IMP_base._TestObject___repr__(self)

    def get_from(o):
       return _object_cast_to__TestObject(o)
    get_from = staticmethod(get_from)

_TestObject_swigregister = _IMP_base._TestObject_swigregister
_TestObject_swigregister(_TestObject)


def get_live_object_names():
  """get_live_object_names() -> IMP::Strings"""
  return _IMP_base.get_live_object_names()

def get_live_objects():
  """get_live_objects() -> IMP::base::Objects"""
  return _IMP_base.get_live_objects()

def set_show_leaked_objects(*args):
  """set_show_leaked_objects(bool tf)"""
  return _IMP_base.set_show_leaked_objects(*args)

def set_deprecation_warnings(*args):
  """set_deprecation_warnings(bool tf)"""
  return _IMP_base.set_deprecation_warnings(*args)

def set_deprecation_exceptions(*args):
  """set_deprecation_exceptions(bool tf)"""
  return _IMP_base.set_deprecation_exceptions(*args)

def handle_use_deprecated(*args):
  """handle_use_deprecated(std::string message)"""
  return _IMP_base.handle_use_deprecated(*args)

def get_number_of_threads():
  """get_number_of_threads() -> unsigned int"""
  return _IMP_base.get_number_of_threads()

def set_number_of_threads(*args):
  """set_number_of_threads(unsigned int n)"""
  return _IMP_base.set_number_of_threads(*args)
class SetNumberOfThreads(_RAII):
    """Proxy of C++ IMP::base::SetNumberOfThreads class"""
    __swig_setmethods__ = {}
    for _s in [_RAII]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SetNumberOfThreads, name, value)
    __swig_getmethods__ = {}
    for _s in [_RAII]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SetNumberOfThreads, name)
    def __init__(self, *args): 
        """
        __init__(IMP::base::SetNumberOfThreads self) -> SetNumberOfThreads
        __init__(IMP::base::SetNumberOfThreads self, unsigned int n) -> SetNumberOfThreads
        """
        this = _IMP_base.new_SetNumberOfThreads(*args)
        try: self.this.append(this)
        except: self.this = this
    def set(self, *args):
        """set(SetNumberOfThreads self, unsigned int n)"""
        return _IMP_base.SetNumberOfThreads_set(self, *args)

    def reset(self):
        """reset(SetNumberOfThreads self)"""
        return _IMP_base.SetNumberOfThreads_reset(self)

    __swig_destroy__ = _IMP_base.delete_SetNumberOfThreads
    __del__ = lambda self : None;
    def show(self, *args):
        """
        show(SetNumberOfThreads self, _ostream out=std::cout)
        show(SetNumberOfThreads self)
        """
        return _IMP_base.SetNumberOfThreads_show(self, *args)

    def __str__(self):
        """__str__(SetNumberOfThreads self) -> std::string"""
        return _IMP_base.SetNumberOfThreads___str__(self)

    def __repr__(self):
        """__repr__(SetNumberOfThreads self) -> std::string"""
        return _IMP_base.SetNumberOfThreads___repr__(self)

SetNumberOfThreads_swigregister = _IMP_base.SetNumberOfThreads_swigregister
SetNumberOfThreads_swigregister(SetNumberOfThreads)


def clear_statistics():
  """clear_statistics()"""
  return _IMP_base.clear_statistics()

def show_timings(*args):
  """show_timings(TextOutput out)"""
  return _IMP_base.show_timings(*args)
class Timer(_RAII):
    """Proxy of C++ IMP::base::Timer class"""
    __swig_setmethods__ = {}
    for _s in [_RAII]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Timer, name, value)
    __swig_getmethods__ = {}
    for _s in [_RAII]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Timer, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(IMP::base::Timer self, Object object, std::string const & operation) -> Timer
        __init__(IMP::base::Timer self, Object object, char const * operation) -> Timer
        __init__(IMP::base::Timer self, std::string operation) -> Timer
        """
        this = _IMP_base.new_Timer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _IMP_base.delete_Timer
    __del__ = lambda self : None;
Timer_swigregister = _IMP_base.Timer_swigregister
Timer_swigregister(Timer)


def set_statistics_level(*args):
  """set_statistics_level(IMP::base::StatisticsLevel l)"""
  return _IMP_base.set_statistics_level(*args)
import _graph_show
show_altgraph= _graph_show.show_altgraph
show_graphviz= _graph_show.show_graphviz
get_networkx_graph= _graph_show.get_networkx_graph


def get_module_version():
  """get_module_version() -> std::string const"""
  return _IMP_base.get_module_version()

def get_example_path(*args):
  """get_example_path(std::string fname) -> std::string"""
  return _IMP_base.get_example_path(*args)

def get_data_path(*args):
  """get_data_path(std::string fname) -> std::string"""
  return _IMP_base.get_data_path(*args)
import _version_check
_version_check.check_version(get_module_version())

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