container/__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_container', [dirname(__file__)])
        except ImportError:
            import _IMP_container
            return _IMP_container
        if fp is not None:
            try:
                _mod = imp.load_module('_IMP_container', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _IMP_container = swig_import_helper()
    del swig_import_helper
else:
    import _IMP_container
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_CONTAINER_SwigPyIterator(_object):
    """Proxy of C++ swig::IMP_CONTAINER_SwigPyIterator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IMP_CONTAINER_SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IMP_CONTAINER_SwigPyIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _IMP_container.delete_IMP_CONTAINER_SwigPyIterator
    __del__ = lambda self : None;
    def value(self):
        """value(IMP_CONTAINER_SwigPyIterator self) -> PyObject *"""
        return _IMP_container.IMP_CONTAINER_SwigPyIterator_value(self)

    def incr(self, n=1):
        """
        incr(IMP_CONTAINER_SwigPyIterator self, size_t n=1) -> IMP_CONTAINER_SwigPyIterator
        incr(IMP_CONTAINER_SwigPyIterator self) -> IMP_CONTAINER_SwigPyIterator
        """
        return _IMP_container.IMP_CONTAINER_SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        """
        decr(IMP_CONTAINER_SwigPyIterator self, size_t n=1) -> IMP_CONTAINER_SwigPyIterator
        decr(IMP_CONTAINER_SwigPyIterator self) -> IMP_CONTAINER_SwigPyIterator
        """
        return _IMP_container.IMP_CONTAINER_SwigPyIterator_decr(self, n)

    def distance(self, *args):
        """distance(IMP_CONTAINER_SwigPyIterator self, IMP_CONTAINER_SwigPyIterator x) -> ptrdiff_t"""
        return _IMP_container.IMP_CONTAINER_SwigPyIterator_distance(self, *args)

    def equal(self, *args):
        """equal(IMP_CONTAINER_SwigPyIterator self, IMP_CONTAINER_SwigPyIterator x) -> bool"""
        return _IMP_container.IMP_CONTAINER_SwigPyIterator_equal(self, *args)

    def copy(self):
        """copy(IMP_CONTAINER_SwigPyIterator self) -> IMP_CONTAINER_SwigPyIterator"""
        return _IMP_container.IMP_CONTAINER_SwigPyIterator_copy(self)

    def next(self):
        """next(IMP_CONTAINER_SwigPyIterator self) -> PyObject *"""
        return _IMP_container.IMP_CONTAINER_SwigPyIterator_next(self)

    def __next__(self):
        """__next__(IMP_CONTAINER_SwigPyIterator self) -> PyObject *"""
        return _IMP_container.IMP_CONTAINER_SwigPyIterator___next__(self)

    def previous(self):
        """previous(IMP_CONTAINER_SwigPyIterator self) -> PyObject *"""
        return _IMP_container.IMP_CONTAINER_SwigPyIterator_previous(self)

    def advance(self, *args):
        """advance(IMP_CONTAINER_SwigPyIterator self, ptrdiff_t n) -> IMP_CONTAINER_SwigPyIterator"""
        return _IMP_container.IMP_CONTAINER_SwigPyIterator_advance(self, *args)

    def __eq__(self, *args):
        """__eq__(IMP_CONTAINER_SwigPyIterator self, IMP_CONTAINER_SwigPyIterator x) -> bool"""
        return _IMP_container.IMP_CONTAINER_SwigPyIterator___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(IMP_CONTAINER_SwigPyIterator self, IMP_CONTAINER_SwigPyIterator x) -> bool"""
        return _IMP_container.IMP_CONTAINER_SwigPyIterator___ne__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(IMP_CONTAINER_SwigPyIterator self, ptrdiff_t n) -> IMP_CONTAINER_SwigPyIterator"""
        return _IMP_container.IMP_CONTAINER_SwigPyIterator___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(IMP_CONTAINER_SwigPyIterator self, ptrdiff_t n) -> IMP_CONTAINER_SwigPyIterator"""
        return _IMP_container.IMP_CONTAINER_SwigPyIterator___isub__(self, *args)

    def __add__(self, *args):
        """__add__(IMP_CONTAINER_SwigPyIterator self, ptrdiff_t n) -> IMP_CONTAINER_SwigPyIterator"""
        return _IMP_container.IMP_CONTAINER_SwigPyIterator___add__(self, *args)

    def __sub__(self, *args):
        """
        __sub__(IMP_CONTAINER_SwigPyIterator self, ptrdiff_t n) -> IMP_CONTAINER_SwigPyIterator
        __sub__(IMP_CONTAINER_SwigPyIterator self, IMP_CONTAINER_SwigPyIterator x) -> ptrdiff_t
        """
        return _IMP_container.IMP_CONTAINER_SwigPyIterator___sub__(self, *args)

    def __iter__(self): return self
IMP_CONTAINER_SwigPyIterator_swigregister = _IMP_container.IMP_CONTAINER_SwigPyIterator_swigregister
IMP_CONTAINER_SwigPyIterator_swigregister(IMP_CONTAINER_SwigPyIterator)

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

IMP_DEBUG = _IMP_container.IMP_DEBUG
IMP_RELEASE = _IMP_container.IMP_RELEASE
IMP_SILENT = _IMP_container.IMP_SILENT
IMP_PROGRESS = _IMP_container.IMP_PROGRESS
IMP_TERSE = _IMP_container.IMP_TERSE
IMP_VERBOSE = _IMP_container.IMP_VERBOSE
IMP_MEMORY = _IMP_container.IMP_MEMORY
IMP_NONE = _IMP_container.IMP_NONE
IMP_USAGE = _IMP_container.IMP_USAGE
IMP_INTERNAL = _IMP_container.IMP_INTERNAL
IMP_BASE_HAS_LOG4CXX = _IMP_container.IMP_BASE_HAS_LOG4CXX
IMP_COMPILER_HAS_AUTO = _IMP_container.IMP_COMPILER_HAS_AUTO
IMP_COMPILER_HAS_DEBUG_VECTOR = _IMP_container.IMP_COMPILER_HAS_DEBUG_VECTOR
IMP_BASE_HAS_BOOST_RANDOM = _IMP_container.IMP_BASE_HAS_BOOST_RANDOM
IMP_BASE_HAS_GPERFTOOLS = _IMP_container.IMP_BASE_HAS_GPERFTOOLS
IMP_BASE_HAS_TCMALLOC_HEAPCHECKER = _IMP_container.IMP_BASE_HAS_TCMALLOC_HEAPCHECKER
IMP_BASE_HAS_TCMALLOC_HEAPPROFILER = _IMP_container.IMP_BASE_HAS_TCMALLOC_HEAPPROFILER
IMPBASE_SHOW_WARNINGS = _IMP_container.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_container.DEFAULT_CHECK
NONE = _IMP_container.NONE
USAGE = _IMP_container.USAGE
USAGE_AND_INTERNAL = _IMP_container.USAGE_AND_INTERNAL

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

def get_check_level():
  """get_check_level() -> IMP::base::CheckLevel"""
  return _IMP_container.get_check_level()
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_container._ostream_write(self, *args)

_ostream_swigregister = _IMP_container._ostream_swigregister
_ostream_swigregister(_ostream)

IMP_COMPILER_HAS_OVERRIDE = _IMP_container.IMP_COMPILER_HAS_OVERRIDE
IMP_COMPILER_HAS_FINAL = _IMP_container.IMP_COMPILER_HAS_FINAL
IMP_HAS_NOEXCEPT = _IMP_container.IMP_HAS_NOEXCEPT
import IMP.base
IMP_CGAL_HAS_BOOST_FILESYSTEM = _IMP_container.IMP_CGAL_HAS_BOOST_FILESYSTEM
IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS = _IMP_container.IMP_CGAL_HAS_BOOST_PROGRAMOPTIONS
IMP_CGAL_HAS_BOOST_RANDOM = _IMP_container.IMP_CGAL_HAS_BOOST_RANDOM
IMP_CGAL_HAS_BOOST_SYSTEM = _IMP_container.IMP_CGAL_HAS_BOOST_SYSTEM
IMPCGAL_SHOW_WARNINGS = _IMP_container.IMPCGAL_SHOW_WARNINGS
import IMP.cgal
IMP_ALGEBRA_HAS_IMP_CGAL = _IMP_container.IMP_ALGEBRA_HAS_IMP_CGAL
IMP_ALGEBRA_HAS_BOOST_FILESYSTEM = _IMP_container.IMP_ALGEBRA_HAS_BOOST_FILESYSTEM
IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS = _IMP_container.IMP_ALGEBRA_HAS_BOOST_PROGRAMOPTIONS
IMP_ALGEBRA_HAS_BOOST_RANDOM = _IMP_container.IMP_ALGEBRA_HAS_BOOST_RANDOM
IMP_ALGEBRA_HAS_BOOST_SYSTEM = _IMP_container.IMP_ALGEBRA_HAS_BOOST_SYSTEM
IMP_ALGEBRA_HAS_CGAL = _IMP_container.IMP_ALGEBRA_HAS_CGAL
IMP_ALGEBRA_HAS_ANN = _IMP_container.IMP_ALGEBRA_HAS_ANN
IMPALGEBRA_SHOW_WARNINGS = _IMP_container.IMPALGEBRA_SHOW_WARNINGS
import IMP.algebra
IMP_KERNEL_HAS_IMP_CGAL = _IMP_container.IMP_KERNEL_HAS_IMP_CGAL
IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS = _IMP_container.IMP_KERNEL_HAS_BOOST_PROGRAMOPTIONS
IMP_KERNEL_HAS_BOOST_RANDOM = _IMP_container.IMP_KERNEL_HAS_BOOST_RANDOM
IMP_KERNEL_HAS_BOOST_SYSTEM = _IMP_container.IMP_KERNEL_HAS_BOOST_SYSTEM
IMP_KERNEL_HAS_CGAL = _IMP_container.IMP_KERNEL_HAS_CGAL
IMPKERNEL_SHOW_WARNINGS = _IMP_container.IMPKERNEL_SHOW_WARNINGS
import IMP.kernel
IMP_DISPLAY_HAS_IMP_BASE = _IMP_container.IMP_DISPLAY_HAS_IMP_BASE
IMP_DISPLAY_HAS_IMP_CGAL = _IMP_container.IMP_DISPLAY_HAS_IMP_CGAL
IMP_DISPLAY_HAS_BOOST_FILESYSTEM = _IMP_container.IMP_DISPLAY_HAS_BOOST_FILESYSTEM
IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS = _IMP_container.IMP_DISPLAY_HAS_BOOST_PROGRAMOPTIONS
IMP_DISPLAY_HAS_BOOST_RANDOM = _IMP_container.IMP_DISPLAY_HAS_BOOST_RANDOM
IMP_DISPLAY_HAS_BOOST_SYSTEM = _IMP_container.IMP_DISPLAY_HAS_BOOST_SYSTEM
IMP_DISPLAY_HAS_CGAL = _IMP_container.IMP_DISPLAY_HAS_CGAL
IMPDISPLAY_SHOW_WARNINGS = _IMP_container.IMPDISPLAY_SHOW_WARNINGS
import IMP.display
IMP_SCORE_FUNCTOR_HAS_IMP_CGAL = _IMP_container.IMP_SCORE_FUNCTOR_HAS_IMP_CGAL
IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM = _IMP_container.IMP_SCORE_FUNCTOR_HAS_BOOST_FILESYSTEM
IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS = _IMP_container.IMP_SCORE_FUNCTOR_HAS_BOOST_PROGRAMOPTIONS
IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM = _IMP_container.IMP_SCORE_FUNCTOR_HAS_BOOST_RANDOM
IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM = _IMP_container.IMP_SCORE_FUNCTOR_HAS_BOOST_SYSTEM
IMP_SCORE_FUNCTOR_HAS_CGAL = _IMP_container.IMP_SCORE_FUNCTOR_HAS_CGAL
IMP_SCORE_FUNCTOR_HAS_HDF5 = _IMP_container.IMP_SCORE_FUNCTOR_HAS_HDF5
IMPSCOREFUNCTOR_SHOW_WARNINGS = _IMP_container.IMPSCOREFUNCTOR_SHOW_WARNINGS
import IMP.score_functor
IMP_CORE_HAS_IMP_BASE = _IMP_container.IMP_CORE_HAS_IMP_BASE
IMP_CORE_HAS_IMP_CGAL = _IMP_container.IMP_CORE_HAS_IMP_CGAL
IMP_CORE_HAS_IMP_KERNEL = _IMP_container.IMP_CORE_HAS_IMP_KERNEL
IMP_CORE_HAS_BOOST_FILESYSTEM = _IMP_container.IMP_CORE_HAS_BOOST_FILESYSTEM
IMP_CORE_HAS_BOOST_PROGRAMOPTIONS = _IMP_container.IMP_CORE_HAS_BOOST_PROGRAMOPTIONS
IMP_CORE_HAS_BOOST_RANDOM = _IMP_container.IMP_CORE_HAS_BOOST_RANDOM
IMP_CORE_HAS_BOOST_SYSTEM = _IMP_container.IMP_CORE_HAS_BOOST_SYSTEM
IMP_CORE_HAS_CGAL = _IMP_container.IMP_CORE_HAS_CGAL
IMP_CORE_HAS_HDF5 = _IMP_container.IMP_CORE_HAS_HDF5
IMPCORE_SHOW_WARNINGS = _IMP_container.IMPCORE_SHOW_WARNINGS
import IMP.core
IMP_CONTAINER_HAS_IMP_ALGEBRA = _IMP_container.IMP_CONTAINER_HAS_IMP_ALGEBRA
IMP_CONTAINER_HAS_IMP_BASE = _IMP_container.IMP_CONTAINER_HAS_IMP_BASE
IMP_CONTAINER_HAS_IMP_CGAL = _IMP_container.IMP_CONTAINER_HAS_IMP_CGAL
IMP_CONTAINER_HAS_IMP_DISPLAY = _IMP_container.IMP_CONTAINER_HAS_IMP_DISPLAY
IMP_CONTAINER_HAS_IMP_KERNEL = _IMP_container.IMP_CONTAINER_HAS_IMP_KERNEL
IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR = _IMP_container.IMP_CONTAINER_HAS_IMP_SCORE_FUNCTOR
IMP_CONTAINER_HAS_BOOST_FILESYSTEM = _IMP_container.IMP_CONTAINER_HAS_BOOST_FILESYSTEM
IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS = _IMP_container.IMP_CONTAINER_HAS_BOOST_PROGRAMOPTIONS
IMP_CONTAINER_HAS_BOOST_RANDOM = _IMP_container.IMP_CONTAINER_HAS_BOOST_RANDOM
IMP_CONTAINER_HAS_BOOST_SYSTEM = _IMP_container.IMP_CONTAINER_HAS_BOOST_SYSTEM
IMP_CONTAINER_HAS_CGAL = _IMP_container.IMP_CONTAINER_HAS_CGAL
IMP_CONTAINER_HAS_HDF5 = _IMP_container.IMP_CONTAINER_HAS_HDF5
IMPCONTAINER_SHOW_WARNINGS = _IMP_container.IMPCONTAINER_SHOW_WARNINGS
_object_types.append("AllBipartitePairContainer")


def _object_cast_to_AllBipartitePairContainer(*args):
  """_object_cast_to_AllBipartitePairContainer(Object o) -> AllBipartitePairContainer"""
  return _IMP_container._object_cast_to_AllBipartitePairContainer(*args)
_object_types.append("AllPairContainer")


def _object_cast_to_AllPairContainer(*args):
  """_object_cast_to_AllPairContainer(Object o) -> AllPairContainer"""
  return _IMP_container._object_cast_to_AllPairContainer(*args)
_object_types.append("CloseBipartitePairContainer")


def _object_cast_to_CloseBipartitePairContainer(*args):
  """_object_cast_to_CloseBipartitePairContainer(Object o) -> CloseBipartitePairContainer"""
  return _IMP_container._object_cast_to_CloseBipartitePairContainer(*args)
_object_types.append("ClosePairContainer")


def _object_cast_to_ClosePairContainer(*args):
  """_object_cast_to_ClosePairContainer(Object o) -> ClosePairContainer"""
  return _IMP_container._object_cast_to_ClosePairContainer(*args)
_object_types.append("ConnectingPairContainer")


def _object_cast_to_ConnectingPairContainer(*args):
  """_object_cast_to_ConnectingPairContainer(Object o) -> ConnectingPairContainer"""
  return _IMP_container._object_cast_to_ConnectingPairContainer(*args)
_object_types.append("ConsecutivePairContainer")


def _object_cast_to_ConsecutivePairContainer(*args):
  """_object_cast_to_ConsecutivePairContainer(Object o) -> ConsecutivePairContainer"""
  return _IMP_container._object_cast_to_ConsecutivePairContainer(*args)
_object_types.append("ExclusiveConsecutivePairContainer")


def _object_cast_to_ExclusiveConsecutivePairContainer(*args):
  """_object_cast_to_ExclusiveConsecutivePairContainer(Object o) -> ExclusiveConsecutivePairContainer"""
  return _IMP_container._object_cast_to_ExclusiveConsecutivePairContainer(*args)
_object_types.append("ExclusiveConsecutivePairFilter")


def _object_cast_to_ExclusiveConsecutivePairFilter(*args):
  """_object_cast_to_ExclusiveConsecutivePairFilter(Object o) -> ExclusiveConsecutivePairFilter"""
  return _IMP_container._object_cast_to_ExclusiveConsecutivePairFilter(*args)
_object_types.append("ConsecutivePairFilter")


def _object_cast_to_ConsecutivePairFilter(*args):
  """_object_cast_to_ConsecutivePairFilter(Object o) -> ConsecutivePairFilter"""
  return _IMP_container._object_cast_to_ConsecutivePairFilter(*args)
_object_types.append("ListPairContainer")


def _object_cast_to_ListPairContainer(*args):
  """_object_cast_to_ListPairContainer(Object o) -> ListPairContainer"""
  return _IMP_container._object_cast_to_ListPairContainer(*args)
_object_types.append("ListQuadContainer")


def _object_cast_to_ListQuadContainer(*args):
  """_object_cast_to_ListQuadContainer(Object o) -> ListQuadContainer"""
  return _IMP_container._object_cast_to_ListQuadContainer(*args)
_object_types.append("ListSingletonContainer")


def _object_cast_to_ListSingletonContainer(*args):
  """_object_cast_to_ListSingletonContainer(Object o) -> ListSingletonContainer"""
  return _IMP_container._object_cast_to_ListSingletonContainer(*args)
_object_types.append("ListTripletContainer")


def _object_cast_to_ListTripletContainer(*args):
  """_object_cast_to_ListTripletContainer(Object o) -> ListTripletContainer"""
  return _IMP_container._object_cast_to_ListTripletContainer(*args)
_object_types.append("DynamicListPairContainer")


def _object_cast_to_DynamicListPairContainer(*args):
  """_object_cast_to_DynamicListPairContainer(Object o) -> DynamicListPairContainer"""
  return _IMP_container._object_cast_to_DynamicListPairContainer(*args)
_object_types.append("DynamicListQuadContainer")


def _object_cast_to_DynamicListQuadContainer(*args):
  """_object_cast_to_DynamicListQuadContainer(Object o) -> DynamicListQuadContainer"""
  return _IMP_container._object_cast_to_DynamicListQuadContainer(*args)
_object_types.append("DynamicListSingletonContainer")


def _object_cast_to_DynamicListSingletonContainer(*args):
  """_object_cast_to_DynamicListSingletonContainer(Object o) -> DynamicListSingletonContainer"""
  return _IMP_container._object_cast_to_DynamicListSingletonContainer(*args)
_object_types.append("DynamicListTripletContainer")


def _object_cast_to_DynamicListTripletContainer(*args):
  """_object_cast_to_DynamicListTripletContainer(Object o) -> DynamicListTripletContainer"""
  return _IMP_container._object_cast_to_DynamicListTripletContainer(*args)
_object_types.append("MinimumPairRestraint")


def _object_cast_to_MinimumPairRestraint(*args):
  """_object_cast_to_MinimumPairRestraint(Object o) -> MinimumPairRestraint"""
  return _IMP_container._object_cast_to_MinimumPairRestraint(*args)
_object_types.append("MinimumPairScore")


def _object_cast_to_MinimumPairScore(*args):
  """_object_cast_to_MinimumPairScore(Object o) -> MinimumPairScore"""
  return _IMP_container._object_cast_to_MinimumPairScore(*args)
_object_types.append("MinimumQuadRestraint")


def _object_cast_to_MinimumQuadRestraint(*args):
  """_object_cast_to_MinimumQuadRestraint(Object o) -> MinimumQuadRestraint"""
  return _IMP_container._object_cast_to_MinimumQuadRestraint(*args)
_object_types.append("MinimumQuadScore")


def _object_cast_to_MinimumQuadScore(*args):
  """_object_cast_to_MinimumQuadScore(Object o) -> MinimumQuadScore"""
  return _IMP_container._object_cast_to_MinimumQuadScore(*args)
_object_types.append("MinimumSingletonRestraint")


def _object_cast_to_MinimumSingletonRestraint(*args):
  """_object_cast_to_MinimumSingletonRestraint(Object o) -> MinimumSingletonRestraint"""
  return _IMP_container._object_cast_to_MinimumSingletonRestraint(*args)
_object_types.append("MinimumSingletonScore")


def _object_cast_to_MinimumSingletonScore(*args):
  """_object_cast_to_MinimumSingletonScore(Object o) -> MinimumSingletonScore"""
  return _IMP_container._object_cast_to_MinimumSingletonScore(*args)
_object_types.append("MinimumTripletRestraint")


def _object_cast_to_MinimumTripletRestraint(*args):
  """_object_cast_to_MinimumTripletRestraint(Object o) -> MinimumTripletRestraint"""
  return _IMP_container._object_cast_to_MinimumTripletRestraint(*args)
_object_types.append("MinimumTripletScore")


def _object_cast_to_MinimumTripletScore(*args):
  """_object_cast_to_MinimumTripletScore(Object o) -> MinimumTripletScore"""
  return _IMP_container._object_cast_to_MinimumTripletScore(*args)
_object_types.append("PairContainerSet")


def _object_cast_to_PairContainerSet(*args):
  """_object_cast_to_PairContainerSet(Object o) -> PairContainerSet"""
  return _IMP_container._object_cast_to_PairContainerSet(*args)
_object_types.append("PairsConstraint")


def _object_cast_to_PairsConstraint(*args):
  """_object_cast_to_PairsConstraint(Object o) -> PairsConstraint"""
  return _IMP_container._object_cast_to_PairsConstraint(*args)
_object_types.append("PairsOptimizerState")


def _object_cast_to_PairsOptimizerState(*args):
  """_object_cast_to_PairsOptimizerState(Object o) -> PairsOptimizerState"""
  return _IMP_container._object_cast_to_PairsOptimizerState(*args)
_object_types.append("PairsRestraint")


def _object_cast_to_PairsRestraint(*args):
  """_object_cast_to_PairsRestraint(Object o) -> PairsRestraint"""
  return _IMP_container._object_cast_to_PairsRestraint(*args)
_object_types.append("QuadContainerSet")


def _object_cast_to_QuadContainerSet(*args):
  """_object_cast_to_QuadContainerSet(Object o) -> QuadContainerSet"""
  return _IMP_container._object_cast_to_QuadContainerSet(*args)
_object_types.append("QuadsConstraint")


def _object_cast_to_QuadsConstraint(*args):
  """_object_cast_to_QuadsConstraint(Object o) -> QuadsConstraint"""
  return _IMP_container._object_cast_to_QuadsConstraint(*args)
_object_types.append("QuadsOptimizerState")


def _object_cast_to_QuadsOptimizerState(*args):
  """_object_cast_to_QuadsOptimizerState(Object o) -> QuadsOptimizerState"""
  return _IMP_container._object_cast_to_QuadsOptimizerState(*args)
_object_types.append("QuadsRestraint")


def _object_cast_to_QuadsRestraint(*args):
  """_object_cast_to_QuadsRestraint(Object o) -> QuadsRestraint"""
  return _IMP_container._object_cast_to_QuadsRestraint(*args)
_object_types.append("SingletonContainerSet")


def _object_cast_to_SingletonContainerSet(*args):
  """_object_cast_to_SingletonContainerSet(Object o) -> SingletonContainerSet"""
  return _IMP_container._object_cast_to_SingletonContainerSet(*args)
_object_types.append("SingletonsConstraint")


def _object_cast_to_SingletonsConstraint(*args):
  """_object_cast_to_SingletonsConstraint(Object o) -> SingletonsConstraint"""
  return _IMP_container._object_cast_to_SingletonsConstraint(*args)
_object_types.append("SingletonsOptimizerState")


def _object_cast_to_SingletonsOptimizerState(*args):
  """_object_cast_to_SingletonsOptimizerState(Object o) -> SingletonsOptimizerState"""
  return _IMP_container._object_cast_to_SingletonsOptimizerState(*args)
_object_types.append("SingletonsRestraint")


def _object_cast_to_SingletonsRestraint(*args):
  """_object_cast_to_SingletonsRestraint(Object o) -> SingletonsRestraint"""
  return _IMP_container._object_cast_to_SingletonsRestraint(*args)
_object_types.append("TripletContainerSet")


def _object_cast_to_TripletContainerSet(*args):
  """_object_cast_to_TripletContainerSet(Object o) -> TripletContainerSet"""
  return _IMP_container._object_cast_to_TripletContainerSet(*args)
_object_types.append("TripletsConstraint")


def _object_cast_to_TripletsConstraint(*args):
  """_object_cast_to_TripletsConstraint(Object o) -> TripletsConstraint"""
  return _IMP_container._object_cast_to_TripletsConstraint(*args)
_object_types.append("TripletsOptimizerState")


def _object_cast_to_TripletsOptimizerState(*args):
  """_object_cast_to_TripletsOptimizerState(Object o) -> TripletsOptimizerState"""
  return _IMP_container._object_cast_to_TripletsOptimizerState(*args)
_object_types.append("TripletsRestraint")


def _object_cast_to_TripletsRestraint(*args):
  """_object_cast_to_TripletsRestraint(Object o) -> TripletsRestraint"""
  return _IMP_container._object_cast_to_TripletsRestraint(*args)
_object_types.append("InContainerSingletonFilter")


def _object_cast_to_InContainerSingletonFilter(*args):
  """_object_cast_to_InContainerSingletonFilter(Object o) -> InContainerSingletonFilter"""
  return _IMP_container._object_cast_to_InContainerSingletonFilter(*args)
_object_types.append("InContainerPairFilter")


def _object_cast_to_InContainerPairFilter(*args):
  """_object_cast_to_InContainerPairFilter(Object o) -> InContainerPairFilter"""
  return _IMP_container._object_cast_to_InContainerPairFilter(*args)
_object_types.append("InContainerTripletFilter")


def _object_cast_to_InContainerTripletFilter(*args):
  """_object_cast_to_InContainerTripletFilter(Object o) -> InContainerTripletFilter"""
  return _IMP_container._object_cast_to_InContainerTripletFilter(*args)
_object_types.append("InContainerQuadFilter")


def _object_cast_to_InContainerQuadFilter(*args):
  """_object_cast_to_InContainerQuadFilter(Object o) -> InContainerQuadFilter"""
  return _IMP_container._object_cast_to_InContainerQuadFilter(*args)
_object_types.append("SingletonContainerStatistics")


def _object_cast_to_SingletonContainerStatistics(*args):
  """_object_cast_to_SingletonContainerStatistics(Object o) -> SingletonContainerStatistics"""
  return _IMP_container._object_cast_to_SingletonContainerStatistics(*args)
_object_types.append("PairContainerStatistics")


def _object_cast_to_PairContainerStatistics(*args):
  """_object_cast_to_PairContainerStatistics(Object o) -> PairContainerStatistics"""
  return _IMP_container._object_cast_to_PairContainerStatistics(*args)
_object_types.append("TripletContainerStatistics")


def _object_cast_to_TripletContainerStatistics(*args):
  """_object_cast_to_TripletContainerStatistics(Object o) -> TripletContainerStatistics"""
  return _IMP_container._object_cast_to_TripletContainerStatistics(*args)
_object_types.append("QuadContainerStatistics")


def _object_cast_to_QuadContainerStatistics(*args):
  """_object_cast_to_QuadContainerStatistics(Object o) -> QuadContainerStatistics"""
  return _IMP_container._object_cast_to_QuadContainerStatistics(*args)
_object_types.append("EventSingletonsOptimizerState")


def _object_cast_to_EventSingletonsOptimizerState(*args):
  """_object_cast_to_EventSingletonsOptimizerState(Object o) -> EventSingletonsOptimizerState"""
  return _IMP_container._object_cast_to_EventSingletonsOptimizerState(*args)
_object_types.append("EventPairsOptimizerState")


def _object_cast_to_EventPairsOptimizerState(*args):
  """_object_cast_to_EventPairsOptimizerState(Object o) -> EventPairsOptimizerState"""
  return _IMP_container._object_cast_to_EventPairsOptimizerState(*args)
_object_types.append("EventTripletsOptimizerState")


def _object_cast_to_EventTripletsOptimizerState(*args):
  """_object_cast_to_EventTripletsOptimizerState(Object o) -> EventTripletsOptimizerState"""
  return _IMP_container._object_cast_to_EventTripletsOptimizerState(*args)
_object_types.append("EventQuadsOptimizerState")


def _object_cast_to_EventQuadsOptimizerState(*args):
  """_object_cast_to_EventQuadsOptimizerState(Object o) -> EventQuadsOptimizerState"""
  return _IMP_container._object_cast_to_EventQuadsOptimizerState(*args)
_object_types.append("PredicateSingletonsRestraint")


def _object_cast_to_PredicateSingletonsRestraint(*args):
  """_object_cast_to_PredicateSingletonsRestraint(Object o) -> PredicateSingletonsRestraint"""
  return _IMP_container._object_cast_to_PredicateSingletonsRestraint(*args)
_object_types.append("PredicatePairsRestraint")


def _object_cast_to_PredicatePairsRestraint(*args):
  """_object_cast_to_PredicatePairsRestraint(Object o) -> PredicatePairsRestraint"""
  return _IMP_container._object_cast_to_PredicatePairsRestraint(*args)
_object_types.append("PredicateTripletsRestraint")


def _object_cast_to_PredicateTripletsRestraint(*args):
  """_object_cast_to_PredicateTripletsRestraint(Object o) -> PredicateTripletsRestraint"""
  return _IMP_container._object_cast_to_PredicateTripletsRestraint(*args)
_object_types.append("PredicateQuadsRestraint")


def _object_cast_to_PredicateQuadsRestraint(*args):
  """_object_cast_to_PredicateQuadsRestraint(Object o) -> PredicateQuadsRestraint"""
  return _IMP_container._object_cast_to_PredicateQuadsRestraint(*args)
_object_types.append("DistributeSingletonsScoreState")


def _object_cast_to_DistributeSingletonsScoreState(*args):
  """_object_cast_to_DistributeSingletonsScoreState(Object o) -> DistributeSingletonsScoreState"""
  return _IMP_container._object_cast_to_DistributeSingletonsScoreState(*args)
_object_types.append("DistributePairsScoreState")


def _object_cast_to_DistributePairsScoreState(*args):
  """_object_cast_to_DistributePairsScoreState(Object o) -> DistributePairsScoreState"""
  return _IMP_container._object_cast_to_DistributePairsScoreState(*args)
_object_types.append("DistributeTripletsScoreState")


def _object_cast_to_DistributeTripletsScoreState(*args):
  """_object_cast_to_DistributeTripletsScoreState(Object o) -> DistributeTripletsScoreState"""
  return _IMP_container._object_cast_to_DistributeTripletsScoreState(*args)
_object_types.append("DistributeQuadsScoreState")


def _object_cast_to_DistributeQuadsScoreState(*args):
  """_object_cast_to_DistributeQuadsScoreState(Object o) -> DistributeQuadsScoreState"""
  return _IMP_container._object_cast_to_DistributeQuadsScoreState(*args)
class AllBipartitePairContainer(IMP.kernel.PairContainer):
    """Proxy of C++ IMP::container::AllBipartitePairContainer class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairContainer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AllBipartitePairContainer, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairContainer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AllBipartitePairContainer, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::AllBipartitePairContainer self, _SingletonContainerAdaptor a, _SingletonContainerAdaptor b, std::string name="AllBipartitePairContainer%1%") -> AllBipartitePairContainer
        __init__(IMP::container::AllBipartitePairContainer self, _SingletonContainerAdaptor a, _SingletonContainerAdaptor b) -> AllBipartitePairContainer
        """
        this = _IMP_container.new_AllBipartitePairContainer(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self):
        """do_get_inputs(AllBipartitePairContainer self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.AllBipartitePairContainer_do_get_inputs(self)

    def do_apply(self, *args):
        """do_apply(AllBipartitePairContainer self, PairModifier sm)"""
        return _IMP_container.AllBipartitePairContainer_do_apply(self, *args)

    def get_version_info(self):
        """get_version_info(AllBipartitePairContainer self) -> VersionInfo"""
        return _IMP_container.AllBipartitePairContainer_get_version_info(self)

    def __str__(self):
        """__str__(AllBipartitePairContainer self) -> std::string"""
        return _IMP_container.AllBipartitePairContainer___str__(self)

    def __repr__(self):
        """__repr__(AllBipartitePairContainer self) -> std::string"""
        return _IMP_container.AllBipartitePairContainer___repr__(self)

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

AllBipartitePairContainer_swigregister = _IMP_container.AllBipartitePairContainer_swigregister
AllBipartitePairContainer_swigregister(AllBipartitePairContainer)

class AllPairContainer(IMP.kernel.PairContainer):
    """Proxy of C++ IMP::container::AllPairContainer class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairContainer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AllPairContainer, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairContainer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AllPairContainer, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::AllPairContainer self, _SingletonContainerAdaptor c, std::string name="AllPairContainer%1%") -> AllPairContainer
        __init__(IMP::container::AllPairContainer self, _SingletonContainerAdaptor c) -> AllPairContainer
        """
        this = _IMP_container.new_AllPairContainer(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self):
        """do_get_inputs(AllPairContainer self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.AllPairContainer_do_get_inputs(self)

    def do_apply(self, *args):
        """do_apply(AllPairContainer self, PairModifier sm)"""
        return _IMP_container.AllPairContainer_do_apply(self, *args)

    def get_version_info(self):
        """get_version_info(AllPairContainer self) -> VersionInfo"""
        return _IMP_container.AllPairContainer_get_version_info(self)

    def __str__(self):
        """__str__(AllPairContainer self) -> std::string"""
        return _IMP_container.AllPairContainer___str__(self)

    def __repr__(self):
        """__repr__(AllPairContainer self) -> std::string"""
        return _IMP_container.AllPairContainer___repr__(self)

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

AllPairContainer_swigregister = _IMP_container.AllPairContainer_swigregister
AllPairContainer_swigregister(AllPairContainer)

class CloseBipartitePairContainer(IMP.kernel.PairContainer):
    """Proxy of C++ IMP::container::CloseBipartitePairContainer class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairContainer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CloseBipartitePairContainer, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairContainer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CloseBipartitePairContainer, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::CloseBipartitePairContainer self, _SingletonContainerAdaptor a, _SingletonContainerAdaptor b, double distance, double slack=1, 
            std::string name="CloseBipartitePairContainer%1%") -> CloseBipartitePairContainer
        __init__(IMP::container::CloseBipartitePairContainer self, _SingletonContainerAdaptor a, _SingletonContainerAdaptor b, double distance, double slack=1) -> CloseBipartitePairContainer
        __init__(IMP::container::CloseBipartitePairContainer self, _SingletonContainerAdaptor a, _SingletonContainerAdaptor b, double distance) -> CloseBipartitePairContainer
        __init__(IMP::container::CloseBipartitePairContainer self, _SingletonContainerAdaptor a, _SingletonContainerAdaptor b, double distance, ClosePairsFinder cpf, 
            double slack=1, std::string name="CloseBipartitePairContainer%1%") -> CloseBipartitePairContainer
        __init__(IMP::container::CloseBipartitePairContainer self, _SingletonContainerAdaptor a, _SingletonContainerAdaptor b, double distance, ClosePairsFinder cpf, 
            double slack=1) -> CloseBipartitePairContainer
        __init__(IMP::container::CloseBipartitePairContainer self, _SingletonContainerAdaptor a, _SingletonContainerAdaptor b, double distance, ClosePairsFinder cpf) -> CloseBipartitePairContainer
        """
        this = _IMP_container.new_CloseBipartitePairContainer(*args)
        try: self.this.append(this)
        except: self.this = this
    def remove_pair_filter(self, *args):
        """remove_pair_filter(CloseBipartitePairContainer self, PairPredicate d)"""
        return _IMP_container.CloseBipartitePairContainer_remove_pair_filter(self, *args)

    def remove_pair_filters(self, *args):
        """remove_pair_filters(CloseBipartitePairContainer self, IMP::kernel::PairPredicates const & d)"""
        return _IMP_container.CloseBipartitePairContainer_remove_pair_filters(self, *args)

    def set_pair_filters(self, *args):
        """set_pair_filters(CloseBipartitePairContainer self, IMP::kernel::PairPredicates const & ps)"""
        return _IMP_container.CloseBipartitePairContainer_set_pair_filters(self, *args)

    def set_pair_filters_order(self, *args):
        """set_pair_filters_order(CloseBipartitePairContainer self, IMP::kernel::PairPredicates const & objs)"""
        return _IMP_container.CloseBipartitePairContainer_set_pair_filters_order(self, *args)

    def add_pair_filter(self, *args):
        """add_pair_filter(CloseBipartitePairContainer self, PairPredicate obj) -> unsigned int"""
        return _IMP_container.CloseBipartitePairContainer_add_pair_filter(self, *args)

    def add_pair_filters(self, *args):
        """add_pair_filters(CloseBipartitePairContainer self, IMP::kernel::PairPredicates const & objs)"""
        return _IMP_container.CloseBipartitePairContainer_add_pair_filters(self, *args)

    def clear_pair_filters(self):
        """clear_pair_filters(CloseBipartitePairContainer self)"""
        return _IMP_container.CloseBipartitePairContainer_clear_pair_filters(self)

    def get_number_of_pair_filters(self):
        """get_number_of_pair_filters(CloseBipartitePairContainer self) -> unsigned int"""
        return _IMP_container.CloseBipartitePairContainer_get_number_of_pair_filters(self)

    def get_has_pair_filters(self):
        """get_has_pair_filters(CloseBipartitePairContainer self) -> bool"""
        return _IMP_container.CloseBipartitePairContainer_get_has_pair_filters(self)

    def get_pair_filter(self, *args):
        """get_pair_filter(CloseBipartitePairContainer self, unsigned int i) -> PairPredicate"""
        return _IMP_container.CloseBipartitePairContainer_get_pair_filter(self, *args)

    def get_pair_filters(self):
        """get_pair_filters(CloseBipartitePairContainer self) -> IMP::kernel::PairPredicates"""
        return _IMP_container.CloseBipartitePairContainer_get_pair_filters(self)

    def reserve_pair_filters(self, *args):
        """reserve_pair_filters(CloseBipartitePairContainer self, unsigned int sz)"""
        return _IMP_container.CloseBipartitePairContainer_reserve_pair_filters(self, *args)

    def do_get_inputs(self):
        """do_get_inputs(CloseBipartitePairContainer self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.CloseBipartitePairContainer_do_get_inputs(self)

    def do_apply(self, *args):
        """do_apply(CloseBipartitePairContainer self, PairModifier sm)"""
        return _IMP_container.CloseBipartitePairContainer_do_apply(self, *args)

    def get_version_info(self):
        """get_version_info(CloseBipartitePairContainer self) -> VersionInfo"""
        return _IMP_container.CloseBipartitePairContainer_get_version_info(self)

    def __str__(self):
        """__str__(CloseBipartitePairContainer self) -> std::string"""
        return _IMP_container.CloseBipartitePairContainer___str__(self)

    def __repr__(self):
        """__repr__(CloseBipartitePairContainer self) -> std::string"""
        return _IMP_container.CloseBipartitePairContainer___repr__(self)

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

CloseBipartitePairContainer_swigregister = _IMP_container.CloseBipartitePairContainer_swigregister
CloseBipartitePairContainer_swigregister(CloseBipartitePairContainer)

class ClosePairContainer(IMP.kernel.PairContainer):
    """Proxy of C++ IMP::container::ClosePairContainer class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairContainer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ClosePairContainer, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairContainer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ClosePairContainer, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::ClosePairContainer self, _SingletonContainerAdaptor c, double distance_cutoff, double slack=1, std::string name="ClosePairContainer%1%") -> ClosePairContainer
        __init__(IMP::container::ClosePairContainer self, _SingletonContainerAdaptor c, double distance_cutoff, double slack=1) -> ClosePairContainer
        __init__(IMP::container::ClosePairContainer self, _SingletonContainerAdaptor c, double distance_cutoff) -> ClosePairContainer
        __init__(IMP::container::ClosePairContainer self, _SingletonContainerAdaptor c, double distance_cutoff, ClosePairsFinder cpf, double slack=1, 
            std::string name="ClosePairContainer%1%") -> ClosePairContainer
        __init__(IMP::container::ClosePairContainer self, _SingletonContainerAdaptor c, double distance_cutoff, ClosePairsFinder cpf, double slack=1) -> ClosePairContainer
        __init__(IMP::container::ClosePairContainer self, _SingletonContainerAdaptor c, double distance_cutoff, ClosePairsFinder cpf) -> ClosePairContainer
        """
        this = _IMP_container.new_ClosePairContainer(*args)
        try: self.this.append(this)
        except: self.this = this
    def remove_pair_filter(self, *args):
        """remove_pair_filter(ClosePairContainer self, PairPredicate d)"""
        return _IMP_container.ClosePairContainer_remove_pair_filter(self, *args)

    def remove_pair_filters(self, *args):
        """remove_pair_filters(ClosePairContainer self, IMP::kernel::PairPredicates const & d)"""
        return _IMP_container.ClosePairContainer_remove_pair_filters(self, *args)

    def set_pair_filters(self, *args):
        """set_pair_filters(ClosePairContainer self, IMP::kernel::PairPredicates const & ps)"""
        return _IMP_container.ClosePairContainer_set_pair_filters(self, *args)

    def set_pair_filters_order(self, *args):
        """set_pair_filters_order(ClosePairContainer self, IMP::kernel::PairPredicates const & objs)"""
        return _IMP_container.ClosePairContainer_set_pair_filters_order(self, *args)

    def add_pair_filter(self, *args):
        """add_pair_filter(ClosePairContainer self, PairPredicate obj) -> unsigned int"""
        return _IMP_container.ClosePairContainer_add_pair_filter(self, *args)

    def add_pair_filters(self, *args):
        """add_pair_filters(ClosePairContainer self, IMP::kernel::PairPredicates const & objs)"""
        return _IMP_container.ClosePairContainer_add_pair_filters(self, *args)

    def clear_pair_filters(self):
        """clear_pair_filters(ClosePairContainer self)"""
        return _IMP_container.ClosePairContainer_clear_pair_filters(self)

    def get_number_of_pair_filters(self):
        """get_number_of_pair_filters(ClosePairContainer self) -> unsigned int"""
        return _IMP_container.ClosePairContainer_get_number_of_pair_filters(self)

    def get_has_pair_filters(self):
        """get_has_pair_filters(ClosePairContainer self) -> bool"""
        return _IMP_container.ClosePairContainer_get_has_pair_filters(self)

    def get_pair_filter(self, *args):
        """get_pair_filter(ClosePairContainer self, unsigned int i) -> PairPredicate"""
        return _IMP_container.ClosePairContainer_get_pair_filter(self, *args)

    def get_pair_filters(self):
        """get_pair_filters(ClosePairContainer self) -> IMP::kernel::PairPredicates"""
        return _IMP_container.ClosePairContainer_get_pair_filters(self)

    def reserve_pair_filters(self, *args):
        """reserve_pair_filters(ClosePairContainer self, unsigned int sz)"""
        return _IMP_container.ClosePairContainer_reserve_pair_filters(self, *args)

    def set_slack(self, *args):
        """set_slack(ClosePairContainer self, double s)"""
        return _IMP_container.ClosePairContainer_set_slack(self, *args)

    def get_slack(self):
        """get_slack(ClosePairContainer self) -> double"""
        return _IMP_container.ClosePairContainer_get_slack(self)

    def do_get_inputs(self):
        """do_get_inputs(ClosePairContainer self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.ClosePairContainer_do_get_inputs(self)

    def do_apply(self, *args):
        """do_apply(ClosePairContainer self, PairModifier sm)"""
        return _IMP_container.ClosePairContainer_do_apply(self, *args)

    def get_number_of_update_calls(self):
        """get_number_of_update_calls(ClosePairContainer self) -> unsigned int"""
        return _IMP_container.ClosePairContainer_get_number_of_update_calls(self)

    def get_number_of_full_rebuilds(self):
        """get_number_of_full_rebuilds(ClosePairContainer self) -> unsigned int"""
        return _IMP_container.ClosePairContainer_get_number_of_full_rebuilds(self)

    def get_number_of_partial_rebuilds(self):
        """get_number_of_partial_rebuilds(ClosePairContainer self) -> unsigned int"""
        return _IMP_container.ClosePairContainer_get_number_of_partial_rebuilds(self)

    def get_version_info(self):
        """get_version_info(ClosePairContainer self) -> VersionInfo"""
        return _IMP_container.ClosePairContainer_get_version_info(self)

    def __str__(self):
        """__str__(ClosePairContainer self) -> std::string"""
        return _IMP_container.ClosePairContainer___str__(self)

    def __repr__(self):
        """__repr__(ClosePairContainer self) -> std::string"""
        return _IMP_container.ClosePairContainer___repr__(self)

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

ClosePairContainer_swigregister = _IMP_container.ClosePairContainer_swigregister
ClosePairContainer_swigregister(ClosePairContainer)


def get_slack_estimate(*args):
  """
    get_slack_estimate(IMP::kernel::ParticlesTemp const & ps, double upper_bound, double step, IMP::kernel::RestraintsTemp const & restraints, 
        bool derivatives, Optimizer opt, ClosePairContainer cpc) -> double
    """
  return _IMP_container.get_slack_estimate(*args)
class ConnectingPairContainer(IMP.kernel.PairContainer):
    """Proxy of C++ IMP::container::ConnectingPairContainer class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairContainer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConnectingPairContainer, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairContainer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ConnectingPairContainer, name)
    def __init__(self, *args): 
        """__init__(IMP::container::ConnectingPairContainer self, SingletonContainer sc, double error) -> ConnectingPairContainer"""
        this = _IMP_container.new_ConnectingPairContainer(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self):
        """do_get_inputs(ConnectingPairContainer self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.ConnectingPairContainer_do_get_inputs(self)

    def do_apply(self, *args):
        """do_apply(ConnectingPairContainer self, PairModifier sm)"""
        return _IMP_container.ConnectingPairContainer_do_apply(self, *args)

    def get_version_info(self):
        """get_version_info(ConnectingPairContainer self) -> VersionInfo"""
        return _IMP_container.ConnectingPairContainer_get_version_info(self)

    def __str__(self):
        """__str__(ConnectingPairContainer self) -> std::string"""
        return _IMP_container.ConnectingPairContainer___str__(self)

    def __repr__(self):
        """__repr__(ConnectingPairContainer self) -> std::string"""
        return _IMP_container.ConnectingPairContainer___repr__(self)

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

ConnectingPairContainer_swigregister = _IMP_container.ConnectingPairContainer_swigregister
ConnectingPairContainer_swigregister(ConnectingPairContainer)

class ConsecutivePairContainer(IMP.kernel.PairContainer):
    """Proxy of C++ IMP::container::ConsecutivePairContainer class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairContainer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConsecutivePairContainer, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairContainer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ConsecutivePairContainer, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::ConsecutivePairContainer self, IMP::kernel::ParticlesTemp const & ps, std::string name="ConsecutivePairContainer%1%") -> ConsecutivePairContainer
        __init__(IMP::container::ConsecutivePairContainer self, IMP::kernel::ParticlesTemp const & ps) -> ConsecutivePairContainer
        """
        this = _IMP_container.new_ConsecutivePairContainer(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self):
        """do_get_inputs(ConsecutivePairContainer self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.ConsecutivePairContainer_do_get_inputs(self)

    def do_apply(self, *args):
        """do_apply(ConsecutivePairContainer self, PairModifier sm)"""
        return _IMP_container.ConsecutivePairContainer_do_apply(self, *args)

    def get_version_info(self):
        """get_version_info(ConsecutivePairContainer self) -> VersionInfo"""
        return _IMP_container.ConsecutivePairContainer_get_version_info(self)

    def __str__(self):
        """__str__(ConsecutivePairContainer self) -> std::string"""
        return _IMP_container.ConsecutivePairContainer___str__(self)

    def __repr__(self):
        """__repr__(ConsecutivePairContainer self) -> std::string"""
        return _IMP_container.ConsecutivePairContainer___repr__(self)

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

ConsecutivePairContainer_swigregister = _IMP_container.ConsecutivePairContainer_swigregister
ConsecutivePairContainer_swigregister(ConsecutivePairContainer)

class ConsecutivePairFilter(IMP.kernel.PairPredicate):
    """Proxy of C++ IMP::container::ConsecutivePairFilter class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairPredicate]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConsecutivePairFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairPredicate]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ConsecutivePairFilter, name)
    def __init__(self, *args): 
        """__init__(IMP::container::ConsecutivePairFilter self, ConsecutivePairContainer cpc) -> ConsecutivePairFilter"""
        this = _IMP_container.new_ConsecutivePairFilter(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self, *args):
        """do_get_inputs(ConsecutivePairFilter self, Model m, IMP::kernel::ParticleIndexes const & pi) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.ConsecutivePairFilter_do_get_inputs(self, *args)

    def get_value(self, *args):
        """
        get_value(ConsecutivePairFilter self, IMP::kernel::ParticlePair const & a) -> int
        get_value(ConsecutivePairFilter self, IMP::kernel::ParticlePairsTemp const & o) -> IMP::Ints
        """
        return _IMP_container.ConsecutivePairFilter_get_value(self, *args)

    def get_value_index(self, *args):
        """
        get_value_index(ConsecutivePairFilter self, Model arg2, IMP::kernel::ParticleIndexPair const & pip) -> int
        get_value_index(ConsecutivePairFilter self, Model m, IMP::kernel::ParticleIndexPairs const & o) -> IMP::Ints
        """
        return _IMP_container.ConsecutivePairFilter_get_value_index(self, *args)

    def get_version_info(self):
        """get_version_info(ConsecutivePairFilter self) -> VersionInfo"""
        return _IMP_container.ConsecutivePairFilter_get_version_info(self)

    def __str__(self):
        """__str__(ConsecutivePairFilter self) -> std::string"""
        return _IMP_container.ConsecutivePairFilter___str__(self)

    def __repr__(self):
        """__repr__(ConsecutivePairFilter self) -> std::string"""
        return _IMP_container.ConsecutivePairFilter___repr__(self)

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

ConsecutivePairFilter_swigregister = _IMP_container.ConsecutivePairFilter_swigregister
ConsecutivePairFilter_swigregister(ConsecutivePairFilter)

class ExclusiveConsecutivePairContainer(IMP.kernel.PairContainer):
    """Proxy of C++ IMP::container::ExclusiveConsecutivePairContainer class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairContainer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ExclusiveConsecutivePairContainer, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairContainer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ExclusiveConsecutivePairContainer, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::ExclusiveConsecutivePairContainer self, IMP::kernel::ParticlesTemp const & ps, std::string name="ExclusiveConsecutivePairContainer%1%") -> ExclusiveConsecutivePairContainer
        __init__(IMP::container::ExclusiveConsecutivePairContainer self, IMP::kernel::ParticlesTemp const & ps) -> ExclusiveConsecutivePairContainer
        """
        this = _IMP_container.new_ExclusiveConsecutivePairContainer(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self):
        """do_get_inputs(ExclusiveConsecutivePairContainer self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.ExclusiveConsecutivePairContainer_do_get_inputs(self)

    def do_apply(self, *args):
        """do_apply(ExclusiveConsecutivePairContainer self, PairModifier sm)"""
        return _IMP_container.ExclusiveConsecutivePairContainer_do_apply(self, *args)

    def get_version_info(self):
        """get_version_info(ExclusiveConsecutivePairContainer self) -> VersionInfo"""
        return _IMP_container.ExclusiveConsecutivePairContainer_get_version_info(self)

    def __str__(self):
        """__str__(ExclusiveConsecutivePairContainer self) -> std::string"""
        return _IMP_container.ExclusiveConsecutivePairContainer___str__(self)

    def __repr__(self):
        """__repr__(ExclusiveConsecutivePairContainer self) -> std::string"""
        return _IMP_container.ExclusiveConsecutivePairContainer___repr__(self)

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

ExclusiveConsecutivePairContainer_swigregister = _IMP_container.ExclusiveConsecutivePairContainer_swigregister
ExclusiveConsecutivePairContainer_swigregister(ExclusiveConsecutivePairContainer)

class ExclusiveConsecutivePairFilter(IMP.kernel.PairPredicate):
    """Proxy of C++ IMP::container::ExclusiveConsecutivePairFilter class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairPredicate]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ExclusiveConsecutivePairFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairPredicate]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ExclusiveConsecutivePairFilter, name)
    def __init__(self): 
        """__init__(IMP::container::ExclusiveConsecutivePairFilter self) -> ExclusiveConsecutivePairFilter"""
        this = _IMP_container.new_ExclusiveConsecutivePairFilter()
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self, *args):
        """do_get_inputs(ExclusiveConsecutivePairFilter self, Model m, IMP::kernel::ParticleIndexes const & pi) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.ExclusiveConsecutivePairFilter_do_get_inputs(self, *args)

    def get_value(self, *args):
        """
        get_value(ExclusiveConsecutivePairFilter self, IMP::kernel::ParticlePair const & a) -> int
        get_value(ExclusiveConsecutivePairFilter self, IMP::kernel::ParticlePairsTemp const & o) -> IMP::Ints
        """
        return _IMP_container.ExclusiveConsecutivePairFilter_get_value(self, *args)

    def get_value_index(self, *args):
        """
        get_value_index(ExclusiveConsecutivePairFilter self, Model m, IMP::kernel::ParticleIndexPair const & pip) -> int
        get_value_index(ExclusiveConsecutivePairFilter self, Model m, IMP::kernel::ParticleIndexPairs const & o) -> IMP::Ints
        """
        return _IMP_container.ExclusiveConsecutivePairFilter_get_value_index(self, *args)

    def get_version_info(self):
        """get_version_info(ExclusiveConsecutivePairFilter self) -> VersionInfo"""
        return _IMP_container.ExclusiveConsecutivePairFilter_get_version_info(self)

    def __str__(self):
        """__str__(ExclusiveConsecutivePairFilter self) -> std::string"""
        return _IMP_container.ExclusiveConsecutivePairFilter___str__(self)

    def __repr__(self):
        """__repr__(ExclusiveConsecutivePairFilter self) -> std::string"""
        return _IMP_container.ExclusiveConsecutivePairFilter___repr__(self)

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

ExclusiveConsecutivePairFilter_swigregister = _IMP_container.ExclusiveConsecutivePairFilter_swigregister
ExclusiveConsecutivePairFilter_swigregister(ExclusiveConsecutivePairFilter)

class ListPairContainer(IMP.kernel.PairContainer):
    """Proxy of C++ IMP::container::ListPairContainer class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairContainer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListPairContainer, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairContainer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListPairContainer, name)
    def set_particle_pairs(self, *args):
        """
        set_particle_pairs(ListPairContainer self, IMP::kernel::ParticlePairsTemp const & ps)
        set_particle_pairs(ListPairContainer self, IMP::kernel::ParticleIndexPairs const & contents)
        """
        return _IMP_container.ListPairContainer_set_particle_pairs(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::container::ListPairContainer self, Model m, IMP::kernel::ParticleIndexPairs const & contents, std::string name="ListPairContainer%1%") -> ListPairContainer
        __init__(IMP::container::ListPairContainer self, Model m, IMP::kernel::ParticleIndexPairs const & contents) -> ListPairContainer
        __init__(IMP::container::ListPairContainer self, IMP::kernel::ParticlePairsTemp const & ps, std::string name="ListPairContainer%1%") -> ListPairContainer
        __init__(IMP::container::ListPairContainer self, IMP::kernel::ParticlePairsTemp const & ps) -> ListPairContainer
        __init__(IMP::container::ListPairContainer self, Model m, std::string name="ListPairContainer %1%") -> ListPairContainer
        __init__(IMP::container::ListPairContainer self, Model m) -> ListPairContainer
        __init__(IMP::container::ListPairContainer self, Model m, char const * name) -> ListPairContainer
        """
        this = _IMP_container.new_ListPairContainer(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_particle_pair(self, *args):
        """add_particle_pair(ListPairContainer self, IMP::kernel::ParticlePair const & vt)"""
        return _IMP_container.ListPairContainer_add_particle_pair(self, *args)

    def add_particle_pairs(self, *args):
        """add_particle_pairs(ListPairContainer self, IMP::kernel::ParticlePairsTemp const & c)"""
        return _IMP_container.ListPairContainer_add_particle_pairs(self, *args)

    def clear_particle_pairs(self):
        """clear_particle_pairs(ListPairContainer self)"""
        return _IMP_container.ListPairContainer_clear_particle_pairs(self)

    def do_get_inputs(self):
        """do_get_inputs(ListPairContainer self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.ListPairContainer_do_get_inputs(self)

    def do_apply(self, *args):
        """do_apply(ListPairContainer self, PairModifier sm)"""
        return _IMP_container.ListPairContainer_do_apply(self, *args)

    def get_version_info(self):
        """get_version_info(ListPairContainer self) -> VersionInfo"""
        return _IMP_container.ListPairContainer_get_version_info(self)

    def __str__(self):
        """__str__(ListPairContainer self) -> std::string"""
        return _IMP_container.ListPairContainer___str__(self)

    def __repr__(self):
        """__repr__(ListPairContainer self) -> std::string"""
        return _IMP_container.ListPairContainer___repr__(self)

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

ListPairContainer_swigregister = _IMP_container.ListPairContainer_swigregister
ListPairContainer_swigregister(ListPairContainer)

class ListQuadContainer(IMP.kernel.QuadContainer):
    """Proxy of C++ IMP::container::ListQuadContainer class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.QuadContainer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListQuadContainer, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.QuadContainer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListQuadContainer, name)
    def set_particle_quads(self, *args):
        """
        set_particle_quads(ListQuadContainer self, IMP::kernel::ParticleQuadsTemp const & ps)
        set_particle_quads(ListQuadContainer self, IMP::kernel::ParticleIndexQuads const & contents)
        """
        return _IMP_container.ListQuadContainer_set_particle_quads(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::container::ListQuadContainer self, Model m, IMP::kernel::ParticleIndexQuads const & contents, std::string name="ListQuadContainer%1%") -> ListQuadContainer
        __init__(IMP::container::ListQuadContainer self, Model m, IMP::kernel::ParticleIndexQuads const & contents) -> ListQuadContainer
        __init__(IMP::container::ListQuadContainer self, IMP::kernel::ParticleQuadsTemp const & ps, std::string name="ListQuadContainer%1%") -> ListQuadContainer
        __init__(IMP::container::ListQuadContainer self, IMP::kernel::ParticleQuadsTemp const & ps) -> ListQuadContainer
        __init__(IMP::container::ListQuadContainer self, Model m, std::string name="ListQuadContainer %1%") -> ListQuadContainer
        __init__(IMP::container::ListQuadContainer self, Model m) -> ListQuadContainer
        __init__(IMP::container::ListQuadContainer self, Model m, char const * name) -> ListQuadContainer
        """
        this = _IMP_container.new_ListQuadContainer(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_particle_quad(self, *args):
        """add_particle_quad(ListQuadContainer self, IMP::kernel::ParticleQuad const & vt)"""
        return _IMP_container.ListQuadContainer_add_particle_quad(self, *args)

    def add_particle_quads(self, *args):
        """add_particle_quads(ListQuadContainer self, IMP::kernel::ParticleQuadsTemp const & c)"""
        return _IMP_container.ListQuadContainer_add_particle_quads(self, *args)

    def clear_particle_quads(self):
        """clear_particle_quads(ListQuadContainer self)"""
        return _IMP_container.ListQuadContainer_clear_particle_quads(self)

    def do_get_inputs(self):
        """do_get_inputs(ListQuadContainer self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.ListQuadContainer_do_get_inputs(self)

    def do_apply(self, *args):
        """do_apply(ListQuadContainer self, QuadModifier sm)"""
        return _IMP_container.ListQuadContainer_do_apply(self, *args)

    def get_version_info(self):
        """get_version_info(ListQuadContainer self) -> VersionInfo"""
        return _IMP_container.ListQuadContainer_get_version_info(self)

    def __str__(self):
        """__str__(ListQuadContainer self) -> std::string"""
        return _IMP_container.ListQuadContainer___str__(self)

    def __repr__(self):
        """__repr__(ListQuadContainer self) -> std::string"""
        return _IMP_container.ListQuadContainer___repr__(self)

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

ListQuadContainer_swigregister = _IMP_container.ListQuadContainer_swigregister
ListQuadContainer_swigregister(ListQuadContainer)

class ListSingletonContainer(IMP.kernel.SingletonContainer):
    """Proxy of C++ IMP::container::ListSingletonContainer class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.SingletonContainer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListSingletonContainer, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.SingletonContainer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListSingletonContainer, name)
    def set_particles(self, *args):
        """
        set_particles(ListSingletonContainer self, IMP::kernel::ParticlesTemp const & ps)
        set_particles(ListSingletonContainer self, IMP::kernel::ParticleIndexes const & contents)
        """
        return _IMP_container.ListSingletonContainer_set_particles(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::container::ListSingletonContainer self, Model m, IMP::kernel::ParticleIndexes const & contents, std::string name="ListSingletonContainer%1%") -> ListSingletonContainer
        __init__(IMP::container::ListSingletonContainer self, Model m, IMP::kernel::ParticleIndexes const & contents) -> ListSingletonContainer
        __init__(IMP::container::ListSingletonContainer self, IMP::kernel::ParticlesTemp const & ps, std::string name="ListSingletonContainer%1%") -> ListSingletonContainer
        __init__(IMP::container::ListSingletonContainer self, IMP::kernel::ParticlesTemp const & ps) -> ListSingletonContainer
        __init__(IMP::container::ListSingletonContainer self, Model m, std::string name="ListSingletonContainer %1%") -> ListSingletonContainer
        __init__(IMP::container::ListSingletonContainer self, Model m) -> ListSingletonContainer
        __init__(IMP::container::ListSingletonContainer self, Model m, char const * name) -> ListSingletonContainer
        """
        this = _IMP_container.new_ListSingletonContainer(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_particle(self, *args):
        """add_particle(ListSingletonContainer self, Particle vt)"""
        return _IMP_container.ListSingletonContainer_add_particle(self, *args)

    def add_particles(self, *args):
        """add_particles(ListSingletonContainer self, IMP::kernel::ParticlesTemp const & c)"""
        return _IMP_container.ListSingletonContainer_add_particles(self, *args)

    def clear_particles(self):
        """clear_particles(ListSingletonContainer self)"""
        return _IMP_container.ListSingletonContainer_clear_particles(self)

    def do_get_inputs(self):
        """do_get_inputs(ListSingletonContainer self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.ListSingletonContainer_do_get_inputs(self)

    def do_apply(self, *args):
        """do_apply(ListSingletonContainer self, SingletonModifier sm)"""
        return _IMP_container.ListSingletonContainer_do_apply(self, *args)

    def get_version_info(self):
        """get_version_info(ListSingletonContainer self) -> VersionInfo"""
        return _IMP_container.ListSingletonContainer_get_version_info(self)

    def __str__(self):
        """__str__(ListSingletonContainer self) -> std::string"""
        return _IMP_container.ListSingletonContainer___str__(self)

    def __repr__(self):
        """__repr__(ListSingletonContainer self) -> std::string"""
        return _IMP_container.ListSingletonContainer___repr__(self)

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

ListSingletonContainer_swigregister = _IMP_container.ListSingletonContainer_swigregister
ListSingletonContainer_swigregister(ListSingletonContainer)

class ListTripletContainer(IMP.kernel.TripletContainer):
    """Proxy of C++ IMP::container::ListTripletContainer class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.TripletContainer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListTripletContainer, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.TripletContainer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListTripletContainer, name)
    def set_particle_triplets(self, *args):
        """
        set_particle_triplets(ListTripletContainer self, IMP::kernel::ParticleTripletsTemp const & ps)
        set_particle_triplets(ListTripletContainer self, IMP::kernel::ParticleIndexTriplets const & contents)
        """
        return _IMP_container.ListTripletContainer_set_particle_triplets(self, *args)

    def __init__(self, *args): 
        """
        __init__(IMP::container::ListTripletContainer self, Model m, IMP::kernel::ParticleIndexTriplets const & contents, std::string name="ListTripletContainer%1%") -> ListTripletContainer
        __init__(IMP::container::ListTripletContainer self, Model m, IMP::kernel::ParticleIndexTriplets const & contents) -> ListTripletContainer
        __init__(IMP::container::ListTripletContainer self, IMP::kernel::ParticleTripletsTemp const & ps, std::string name="ListTripletContainer%1%") -> ListTripletContainer
        __init__(IMP::container::ListTripletContainer self, IMP::kernel::ParticleTripletsTemp const & ps) -> ListTripletContainer
        __init__(IMP::container::ListTripletContainer self, Model m, std::string name="ListTripletContainer %1%") -> ListTripletContainer
        __init__(IMP::container::ListTripletContainer self, Model m) -> ListTripletContainer
        __init__(IMP::container::ListTripletContainer self, Model m, char const * name) -> ListTripletContainer
        """
        this = _IMP_container.new_ListTripletContainer(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_particle_triplet(self, *args):
        """add_particle_triplet(ListTripletContainer self, IMP::kernel::ParticleTriplet const & vt)"""
        return _IMP_container.ListTripletContainer_add_particle_triplet(self, *args)

    def add_particle_triplets(self, *args):
        """add_particle_triplets(ListTripletContainer self, IMP::kernel::ParticleTripletsTemp const & c)"""
        return _IMP_container.ListTripletContainer_add_particle_triplets(self, *args)

    def clear_particle_triplets(self):
        """clear_particle_triplets(ListTripletContainer self)"""
        return _IMP_container.ListTripletContainer_clear_particle_triplets(self)

    def do_get_inputs(self):
        """do_get_inputs(ListTripletContainer self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.ListTripletContainer_do_get_inputs(self)

    def do_apply(self, *args):
        """do_apply(ListTripletContainer self, TripletModifier sm)"""
        return _IMP_container.ListTripletContainer_do_apply(self, *args)

    def get_version_info(self):
        """get_version_info(ListTripletContainer self) -> VersionInfo"""
        return _IMP_container.ListTripletContainer_get_version_info(self)

    def __str__(self):
        """__str__(ListTripletContainer self) -> std::string"""
        return _IMP_container.ListTripletContainer___str__(self)

    def __repr__(self):
        """__repr__(ListTripletContainer self) -> std::string"""
        return _IMP_container.ListTripletContainer___repr__(self)

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

ListTripletContainer_swigregister = _IMP_container.ListTripletContainer_swigregister
ListTripletContainer_swigregister(ListTripletContainer)

class DynamicListPairContainer(IMP.kernel.PairContainer):
    """Proxy of C++ IMP::container::DynamicListPairContainer class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairContainer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DynamicListPairContainer, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairContainer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DynamicListPairContainer, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    def add_particle_pair(self, *args):
        """add_particle_pair(DynamicListPairContainer self, IMP::kernel::ParticlePair const & vt)"""
        return _IMP_container.DynamicListPairContainer_add_particle_pair(self, *args)

    def add_particle_pairs(self, *args):
        """add_particle_pairs(DynamicListPairContainer self, IMP::kernel::ParticlePairsTemp const & c)"""
        return _IMP_container.DynamicListPairContainer_add_particle_pairs(self, *args)

    def set_particle_pairs(self, *args):
        """set_particle_pairs(DynamicListPairContainer self, IMP::kernel::ParticlePairsTemp c)"""
        return _IMP_container.DynamicListPairContainer_set_particle_pairs(self, *args)

    def clear_particle_pairs(self):
        """clear_particle_pairs(DynamicListPairContainer self)"""
        return _IMP_container.DynamicListPairContainer_clear_particle_pairs(self)

    def do_get_inputs(self):
        """do_get_inputs(DynamicListPairContainer self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.DynamicListPairContainer_do_get_inputs(self)

    def do_apply(self, *args):
        """do_apply(DynamicListPairContainer self, PairModifier sm)"""
        return _IMP_container.DynamicListPairContainer_do_apply(self, *args)

    def get_version_info(self):
        """get_version_info(DynamicListPairContainer self) -> VersionInfo"""
        return _IMP_container.DynamicListPairContainer_get_version_info(self)

    def __str__(self):
        """__str__(DynamicListPairContainer self) -> std::string"""
        return _IMP_container.DynamicListPairContainer___str__(self)

    def __repr__(self):
        """__repr__(DynamicListPairContainer self) -> std::string"""
        return _IMP_container.DynamicListPairContainer___repr__(self)

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

DynamicListPairContainer_swigregister = _IMP_container.DynamicListPairContainer_swigregister
DynamicListPairContainer_swigregister(DynamicListPairContainer)

class DynamicListQuadContainer(IMP.kernel.QuadContainer):
    """Proxy of C++ IMP::container::DynamicListQuadContainer class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.QuadContainer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DynamicListQuadContainer, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.QuadContainer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DynamicListQuadContainer, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    def add_particle_quad(self, *args):
        """add_particle_quad(DynamicListQuadContainer self, IMP::kernel::ParticleQuad const & vt)"""
        return _IMP_container.DynamicListQuadContainer_add_particle_quad(self, *args)

    def add_particle_quads(self, *args):
        """add_particle_quads(DynamicListQuadContainer self, IMP::kernel::ParticleQuadsTemp const & c)"""
        return _IMP_container.DynamicListQuadContainer_add_particle_quads(self, *args)

    def set_particle_quads(self, *args):
        """set_particle_quads(DynamicListQuadContainer self, IMP::kernel::ParticleQuadsTemp c)"""
        return _IMP_container.DynamicListQuadContainer_set_particle_quads(self, *args)

    def clear_particle_quads(self):
        """clear_particle_quads(DynamicListQuadContainer self)"""
        return _IMP_container.DynamicListQuadContainer_clear_particle_quads(self)

    def do_get_inputs(self):
        """do_get_inputs(DynamicListQuadContainer self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.DynamicListQuadContainer_do_get_inputs(self)

    def do_apply(self, *args):
        """do_apply(DynamicListQuadContainer self, QuadModifier sm)"""
        return _IMP_container.DynamicListQuadContainer_do_apply(self, *args)

    def get_version_info(self):
        """get_version_info(DynamicListQuadContainer self) -> VersionInfo"""
        return _IMP_container.DynamicListQuadContainer_get_version_info(self)

    def __str__(self):
        """__str__(DynamicListQuadContainer self) -> std::string"""
        return _IMP_container.DynamicListQuadContainer___str__(self)

    def __repr__(self):
        """__repr__(DynamicListQuadContainer self) -> std::string"""
        return _IMP_container.DynamicListQuadContainer___repr__(self)

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

DynamicListQuadContainer_swigregister = _IMP_container.DynamicListQuadContainer_swigregister
DynamicListQuadContainer_swigregister(DynamicListQuadContainer)

class DynamicListSingletonContainer(IMP.kernel.SingletonContainer):
    """Proxy of C++ IMP::container::DynamicListSingletonContainer class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.SingletonContainer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DynamicListSingletonContainer, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.SingletonContainer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DynamicListSingletonContainer, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    def add_particle(self, *args):
        """add_particle(DynamicListSingletonContainer self, Particle vt)"""
        return _IMP_container.DynamicListSingletonContainer_add_particle(self, *args)

    def add_particles(self, *args):
        """add_particles(DynamicListSingletonContainer self, IMP::kernel::ParticlesTemp const & c)"""
        return _IMP_container.DynamicListSingletonContainer_add_particles(self, *args)

    def set_particles(self, *args):
        """set_particles(DynamicListSingletonContainer self, IMP::kernel::ParticlesTemp c)"""
        return _IMP_container.DynamicListSingletonContainer_set_particles(self, *args)

    def clear_particles(self):
        """clear_particles(DynamicListSingletonContainer self)"""
        return _IMP_container.DynamicListSingletonContainer_clear_particles(self)

    def do_get_inputs(self):
        """do_get_inputs(DynamicListSingletonContainer self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.DynamicListSingletonContainer_do_get_inputs(self)

    def do_apply(self, *args):
        """do_apply(DynamicListSingletonContainer self, SingletonModifier sm)"""
        return _IMP_container.DynamicListSingletonContainer_do_apply(self, *args)

    def get_version_info(self):
        """get_version_info(DynamicListSingletonContainer self) -> VersionInfo"""
        return _IMP_container.DynamicListSingletonContainer_get_version_info(self)

    def __str__(self):
        """__str__(DynamicListSingletonContainer self) -> std::string"""
        return _IMP_container.DynamicListSingletonContainer___str__(self)

    def __repr__(self):
        """__repr__(DynamicListSingletonContainer self) -> std::string"""
        return _IMP_container.DynamicListSingletonContainer___repr__(self)

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

DynamicListSingletonContainer_swigregister = _IMP_container.DynamicListSingletonContainer_swigregister
DynamicListSingletonContainer_swigregister(DynamicListSingletonContainer)

class DynamicListTripletContainer(IMP.kernel.TripletContainer):
    """Proxy of C++ IMP::container::DynamicListTripletContainer class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.TripletContainer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DynamicListTripletContainer, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.TripletContainer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DynamicListTripletContainer, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    def add_particle_triplet(self, *args):
        """add_particle_triplet(DynamicListTripletContainer self, IMP::kernel::ParticleTriplet const & vt)"""
        return _IMP_container.DynamicListTripletContainer_add_particle_triplet(self, *args)

    def add_particle_triplets(self, *args):
        """add_particle_triplets(DynamicListTripletContainer self, IMP::kernel::ParticleTripletsTemp const & c)"""
        return _IMP_container.DynamicListTripletContainer_add_particle_triplets(self, *args)

    def set_particle_triplets(self, *args):
        """set_particle_triplets(DynamicListTripletContainer self, IMP::kernel::ParticleTripletsTemp c)"""
        return _IMP_container.DynamicListTripletContainer_set_particle_triplets(self, *args)

    def clear_particle_triplets(self):
        """clear_particle_triplets(DynamicListTripletContainer self)"""
        return _IMP_container.DynamicListTripletContainer_clear_particle_triplets(self)

    def do_get_inputs(self):
        """do_get_inputs(DynamicListTripletContainer self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.DynamicListTripletContainer_do_get_inputs(self)

    def do_apply(self, *args):
        """do_apply(DynamicListTripletContainer self, TripletModifier sm)"""
        return _IMP_container.DynamicListTripletContainer_do_apply(self, *args)

    def get_version_info(self):
        """get_version_info(DynamicListTripletContainer self) -> VersionInfo"""
        return _IMP_container.DynamicListTripletContainer_get_version_info(self)

    def __str__(self):
        """__str__(DynamicListTripletContainer self) -> std::string"""
        return _IMP_container.DynamicListTripletContainer___str__(self)

    def __repr__(self):
        """__repr__(DynamicListTripletContainer self) -> std::string"""
        return _IMP_container.DynamicListTripletContainer___repr__(self)

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

DynamicListTripletContainer_swigregister = _IMP_container.DynamicListTripletContainer_swigregister
DynamicListTripletContainer_swigregister(DynamicListTripletContainer)

class MinimumPairRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::container::MinimumPairRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MinimumPairRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MinimumPairRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::MinimumPairRestraint self, PairScore f, _PairContainerAdaptor c, unsigned int n=1, std::string name="MinimumPairRestraint %1%") -> MinimumPairRestraint
        __init__(IMP::container::MinimumPairRestraint self, PairScore f, _PairContainerAdaptor c, unsigned int n=1) -> MinimumPairRestraint
        __init__(IMP::container::MinimumPairRestraint self, PairScore f, _PairContainerAdaptor c) -> MinimumPairRestraint
        """
        this = _IMP_container.new_MinimumPairRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self):
        """do_get_inputs(MinimumPairRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.MinimumPairRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(MinimumPairRestraint self) -> VersionInfo"""
        return _IMP_container.MinimumPairRestraint_get_version_info(self)

    def set_n(self, *args):
        """set_n(MinimumPairRestraint self, unsigned int n)"""
        return _IMP_container.MinimumPairRestraint_set_n(self, *args)

    def do_create_current_decomposition(self):
        """do_create_current_decomposition(MinimumPairRestraint self) -> IMP::kernel::Restraints"""
        return _IMP_container.MinimumPairRestraint_do_create_current_decomposition(self)

    def __str__(self):
        """__str__(MinimumPairRestraint self) -> std::string"""
        return _IMP_container.MinimumPairRestraint___str__(self)

    def __repr__(self):
        """__repr__(MinimumPairRestraint self) -> std::string"""
        return _IMP_container.MinimumPairRestraint___repr__(self)

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

MinimumPairRestraint_swigregister = _IMP_container.MinimumPairRestraint_swigregister
MinimumPairRestraint_swigregister(MinimumPairRestraint)

class MinimumPairScore(IMP.kernel.PairScore):
    """Proxy of C++ IMP::container::MinimumPairScore class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MinimumPairScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MinimumPairScore, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::MinimumPairScore self, IMP::kernel::PairScoresTemp const & scores, unsigned int n=1, std::string name="PairScore %1%") -> MinimumPairScore
        __init__(IMP::container::MinimumPairScore self, IMP::kernel::PairScoresTemp const & scores, unsigned int n=1) -> MinimumPairScore
        __init__(IMP::container::MinimumPairScore self, IMP::kernel::PairScoresTemp const & scores) -> MinimumPairScore
        """
        this = _IMP_container.new_MinimumPairScore(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self, *args):
        """do_get_inputs(MinimumPairScore self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.MinimumPairScore_do_get_inputs(self, *args)

    def get_version_info(self):
        """get_version_info(MinimumPairScore self) -> VersionInfo"""
        return _IMP_container.MinimumPairScore_get_version_info(self)

    def do_create_current_decomposition(self, *args):
        """do_create_current_decomposition(MinimumPairScore self, Model m, IMP::kernel::ParticleIndexPair const & vt) -> IMP::kernel::Restraints"""
        return _IMP_container.MinimumPairScore_do_create_current_decomposition(self, *args)

    def __str__(self):
        """__str__(MinimumPairScore self) -> std::string"""
        return _IMP_container.MinimumPairScore___str__(self)

    def __repr__(self):
        """__repr__(MinimumPairScore self) -> std::string"""
        return _IMP_container.MinimumPairScore___repr__(self)

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

MinimumPairScore_swigregister = _IMP_container.MinimumPairScore_swigregister
MinimumPairScore_swigregister(MinimumPairScore)

class MinimumQuadRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::container::MinimumQuadRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MinimumQuadRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MinimumQuadRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::MinimumQuadRestraint self, QuadScore f, _QuadContainerAdaptor c, unsigned int n=1, std::string name="MinimumQuadRestraint %1%") -> MinimumQuadRestraint
        __init__(IMP::container::MinimumQuadRestraint self, QuadScore f, _QuadContainerAdaptor c, unsigned int n=1) -> MinimumQuadRestraint
        __init__(IMP::container::MinimumQuadRestraint self, QuadScore f, _QuadContainerAdaptor c) -> MinimumQuadRestraint
        """
        this = _IMP_container.new_MinimumQuadRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self):
        """do_get_inputs(MinimumQuadRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.MinimumQuadRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(MinimumQuadRestraint self) -> VersionInfo"""
        return _IMP_container.MinimumQuadRestraint_get_version_info(self)

    def set_n(self, *args):
        """set_n(MinimumQuadRestraint self, unsigned int n)"""
        return _IMP_container.MinimumQuadRestraint_set_n(self, *args)

    def do_create_current_decomposition(self):
        """do_create_current_decomposition(MinimumQuadRestraint self) -> IMP::kernel::Restraints"""
        return _IMP_container.MinimumQuadRestraint_do_create_current_decomposition(self)

    def __str__(self):
        """__str__(MinimumQuadRestraint self) -> std::string"""
        return _IMP_container.MinimumQuadRestraint___str__(self)

    def __repr__(self):
        """__repr__(MinimumQuadRestraint self) -> std::string"""
        return _IMP_container.MinimumQuadRestraint___repr__(self)

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

MinimumQuadRestraint_swigregister = _IMP_container.MinimumQuadRestraint_swigregister
MinimumQuadRestraint_swigregister(MinimumQuadRestraint)

class MinimumQuadScore(IMP.kernel.QuadScore):
    """Proxy of C++ IMP::container::MinimumQuadScore class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.QuadScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MinimumQuadScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.QuadScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MinimumQuadScore, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::MinimumQuadScore self, IMP::kernel::QuadScoresTemp const & scores, unsigned int n=1, std::string name="QuadScore %1%") -> MinimumQuadScore
        __init__(IMP::container::MinimumQuadScore self, IMP::kernel::QuadScoresTemp const & scores, unsigned int n=1) -> MinimumQuadScore
        __init__(IMP::container::MinimumQuadScore self, IMP::kernel::QuadScoresTemp const & scores) -> MinimumQuadScore
        """
        this = _IMP_container.new_MinimumQuadScore(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self, *args):
        """do_get_inputs(MinimumQuadScore self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.MinimumQuadScore_do_get_inputs(self, *args)

    def get_version_info(self):
        """get_version_info(MinimumQuadScore self) -> VersionInfo"""
        return _IMP_container.MinimumQuadScore_get_version_info(self)

    def do_create_current_decomposition(self, *args):
        """do_create_current_decomposition(MinimumQuadScore self, Model m, IMP::kernel::ParticleIndexQuad const & vt) -> IMP::kernel::Restraints"""
        return _IMP_container.MinimumQuadScore_do_create_current_decomposition(self, *args)

    def __str__(self):
        """__str__(MinimumQuadScore self) -> std::string"""
        return _IMP_container.MinimumQuadScore___str__(self)

    def __repr__(self):
        """__repr__(MinimumQuadScore self) -> std::string"""
        return _IMP_container.MinimumQuadScore___repr__(self)

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

MinimumQuadScore_swigregister = _IMP_container.MinimumQuadScore_swigregister
MinimumQuadScore_swigregister(MinimumQuadScore)

class MinimumSingletonRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::container::MinimumSingletonRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MinimumSingletonRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MinimumSingletonRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::MinimumSingletonRestraint self, SingletonScore f, _SingletonContainerAdaptor c, unsigned int n=1, std::string name="MinimumSingletonRestraint %1%") -> MinimumSingletonRestraint
        __init__(IMP::container::MinimumSingletonRestraint self, SingletonScore f, _SingletonContainerAdaptor c, unsigned int n=1) -> MinimumSingletonRestraint
        __init__(IMP::container::MinimumSingletonRestraint self, SingletonScore f, _SingletonContainerAdaptor c) -> MinimumSingletonRestraint
        """
        this = _IMP_container.new_MinimumSingletonRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self):
        """do_get_inputs(MinimumSingletonRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.MinimumSingletonRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(MinimumSingletonRestraint self) -> VersionInfo"""
        return _IMP_container.MinimumSingletonRestraint_get_version_info(self)

    def set_n(self, *args):
        """set_n(MinimumSingletonRestraint self, unsigned int n)"""
        return _IMP_container.MinimumSingletonRestraint_set_n(self, *args)

    def do_create_current_decomposition(self):
        """do_create_current_decomposition(MinimumSingletonRestraint self) -> IMP::kernel::Restraints"""
        return _IMP_container.MinimumSingletonRestraint_do_create_current_decomposition(self)

    def __str__(self):
        """__str__(MinimumSingletonRestraint self) -> std::string"""
        return _IMP_container.MinimumSingletonRestraint___str__(self)

    def __repr__(self):
        """__repr__(MinimumSingletonRestraint self) -> std::string"""
        return _IMP_container.MinimumSingletonRestraint___repr__(self)

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

MinimumSingletonRestraint_swigregister = _IMP_container.MinimumSingletonRestraint_swigregister
MinimumSingletonRestraint_swigregister(MinimumSingletonRestraint)

class MinimumSingletonScore(IMP.kernel.SingletonScore):
    """Proxy of C++ IMP::container::MinimumSingletonScore class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.SingletonScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MinimumSingletonScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.SingletonScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MinimumSingletonScore, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::MinimumSingletonScore self, IMP::kernel::SingletonScoresTemp const & scores, unsigned int n=1, std::string name="SingletonScore %1%") -> MinimumSingletonScore
        __init__(IMP::container::MinimumSingletonScore self, IMP::kernel::SingletonScoresTemp const & scores, unsigned int n=1) -> MinimumSingletonScore
        __init__(IMP::container::MinimumSingletonScore self, IMP::kernel::SingletonScoresTemp const & scores) -> MinimumSingletonScore
        """
        this = _IMP_container.new_MinimumSingletonScore(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self, *args):
        """do_get_inputs(MinimumSingletonScore self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.MinimumSingletonScore_do_get_inputs(self, *args)

    def get_version_info(self):
        """get_version_info(MinimumSingletonScore self) -> VersionInfo"""
        return _IMP_container.MinimumSingletonScore_get_version_info(self)

    def do_create_current_decomposition(self, *args):
        """do_create_current_decomposition(MinimumSingletonScore self, Model m, IMP::kernel::ParticleIndex vt) -> IMP::kernel::Restraints"""
        return _IMP_container.MinimumSingletonScore_do_create_current_decomposition(self, *args)

    def __str__(self):
        """__str__(MinimumSingletonScore self) -> std::string"""
        return _IMP_container.MinimumSingletonScore___str__(self)

    def __repr__(self):
        """__repr__(MinimumSingletonScore self) -> std::string"""
        return _IMP_container.MinimumSingletonScore___repr__(self)

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

MinimumSingletonScore_swigregister = _IMP_container.MinimumSingletonScore_swigregister
MinimumSingletonScore_swigregister(MinimumSingletonScore)

class MinimumTripletRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::container::MinimumTripletRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MinimumTripletRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MinimumTripletRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::MinimumTripletRestraint self, TripletScore f, _TripletContainerAdaptor c, unsigned int n=1, std::string name="MinimumTripletRestraint %1%") -> MinimumTripletRestraint
        __init__(IMP::container::MinimumTripletRestraint self, TripletScore f, _TripletContainerAdaptor c, unsigned int n=1) -> MinimumTripletRestraint
        __init__(IMP::container::MinimumTripletRestraint self, TripletScore f, _TripletContainerAdaptor c) -> MinimumTripletRestraint
        """
        this = _IMP_container.new_MinimumTripletRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self):
        """do_get_inputs(MinimumTripletRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.MinimumTripletRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(MinimumTripletRestraint self) -> VersionInfo"""
        return _IMP_container.MinimumTripletRestraint_get_version_info(self)

    def set_n(self, *args):
        """set_n(MinimumTripletRestraint self, unsigned int n)"""
        return _IMP_container.MinimumTripletRestraint_set_n(self, *args)

    def do_create_current_decomposition(self):
        """do_create_current_decomposition(MinimumTripletRestraint self) -> IMP::kernel::Restraints"""
        return _IMP_container.MinimumTripletRestraint_do_create_current_decomposition(self)

    def __str__(self):
        """__str__(MinimumTripletRestraint self) -> std::string"""
        return _IMP_container.MinimumTripletRestraint___str__(self)

    def __repr__(self):
        """__repr__(MinimumTripletRestraint self) -> std::string"""
        return _IMP_container.MinimumTripletRestraint___repr__(self)

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

MinimumTripletRestraint_swigregister = _IMP_container.MinimumTripletRestraint_swigregister
MinimumTripletRestraint_swigregister(MinimumTripletRestraint)

class MinimumTripletScore(IMP.kernel.TripletScore):
    """Proxy of C++ IMP::container::MinimumTripletScore class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.TripletScore]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MinimumTripletScore, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.TripletScore]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MinimumTripletScore, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::MinimumTripletScore self, IMP::kernel::TripletScoresTemp const & scores, unsigned int n=1, std::string name="TripletScore %1%") -> MinimumTripletScore
        __init__(IMP::container::MinimumTripletScore self, IMP::kernel::TripletScoresTemp const & scores, unsigned int n=1) -> MinimumTripletScore
        __init__(IMP::container::MinimumTripletScore self, IMP::kernel::TripletScoresTemp const & scores) -> MinimumTripletScore
        """
        this = _IMP_container.new_MinimumTripletScore(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self, *args):
        """do_get_inputs(MinimumTripletScore self, Model m, IMP::kernel::ParticleIndexes const & pis) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.MinimumTripletScore_do_get_inputs(self, *args)

    def get_version_info(self):
        """get_version_info(MinimumTripletScore self) -> VersionInfo"""
        return _IMP_container.MinimumTripletScore_get_version_info(self)

    def do_create_current_decomposition(self, *args):
        """do_create_current_decomposition(MinimumTripletScore self, Model m, IMP::kernel::ParticleIndexTriplet const & vt) -> IMP::kernel::Restraints"""
        return _IMP_container.MinimumTripletScore_do_create_current_decomposition(self, *args)

    def __str__(self):
        """__str__(MinimumTripletScore self) -> std::string"""
        return _IMP_container.MinimumTripletScore___str__(self)

    def __repr__(self):
        """__repr__(MinimumTripletScore self) -> std::string"""
        return _IMP_container.MinimumTripletScore___repr__(self)

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

MinimumTripletScore_swigregister = _IMP_container.MinimumTripletScore_swigregister
MinimumTripletScore_swigregister(MinimumTripletScore)

class PairContainerSet(IMP.kernel.PairContainer):
    """Proxy of C++ IMP::container::PairContainerSet class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairContainer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PairContainerSet, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairContainer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PairContainerSet, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::PairContainerSet self, Model m, std::string name="PairContainerSet %1%") -> PairContainerSet
        __init__(IMP::container::PairContainerSet self, Model m) -> PairContainerSet
        __init__(IMP::container::PairContainerSet self, IMP::kernel::PairContainersTemp const & pc, std::string name="PairContainerSet %1%") -> PairContainerSet
        __init__(IMP::container::PairContainerSet self, IMP::kernel::PairContainersTemp const & pc) -> PairContainerSet
        """
        this = _IMP_container.new_PairContainerSet(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_apply(self, *args):
        """do_apply(PairContainerSet self, PairModifier sm)"""
        return _IMP_container.PairContainerSet_do_apply(self, *args)

    def get_version_info(self):
        """get_version_info(PairContainerSet self) -> VersionInfo"""
        return _IMP_container.PairContainerSet_get_version_info(self)

    def remove_pair_container(self, *args):
        """remove_pair_container(PairContainerSet self, PairContainer d)"""
        return _IMP_container.PairContainerSet_remove_pair_container(self, *args)

    def remove_pair_containers(self, *args):
        """remove_pair_containers(PairContainerSet self, IMP::kernel::PairContainers const & d)"""
        return _IMP_container.PairContainerSet_remove_pair_containers(self, *args)

    def set_pair_containers(self, *args):
        """set_pair_containers(PairContainerSet self, IMP::kernel::PairContainers const & ps)"""
        return _IMP_container.PairContainerSet_set_pair_containers(self, *args)

    def set_pair_containers_order(self, *args):
        """set_pair_containers_order(PairContainerSet self, IMP::kernel::PairContainers const & objs)"""
        return _IMP_container.PairContainerSet_set_pair_containers_order(self, *args)

    def add_pair_container(self, *args):
        """add_pair_container(PairContainerSet self, PairContainer obj) -> unsigned int"""
        return _IMP_container.PairContainerSet_add_pair_container(self, *args)

    def add_pair_containers(self, *args):
        """add_pair_containers(PairContainerSet self, IMP::kernel::PairContainers const & objs)"""
        return _IMP_container.PairContainerSet_add_pair_containers(self, *args)

    def clear_pair_containers(self):
        """clear_pair_containers(PairContainerSet self)"""
        return _IMP_container.PairContainerSet_clear_pair_containers(self)

    def get_number_of_pair_containers(self):
        """get_number_of_pair_containers(PairContainerSet self) -> unsigned int"""
        return _IMP_container.PairContainerSet_get_number_of_pair_containers(self)

    def get_has_pair_containers(self):
        """get_has_pair_containers(PairContainerSet self) -> bool"""
        return _IMP_container.PairContainerSet_get_has_pair_containers(self)

    def get_pair_container(self, *args):
        """get_pair_container(PairContainerSet self, unsigned int i) -> PairContainer"""
        return _IMP_container.PairContainerSet_get_pair_container(self, *args)

    def get_pair_containers(self):
        """get_pair_containers(PairContainerSet self) -> IMP::kernel::PairContainers"""
        return _IMP_container.PairContainerSet_get_pair_containers(self)

    def reserve_pair_containers(self, *args):
        """reserve_pair_containers(PairContainerSet self, unsigned int sz)"""
        return _IMP_container.PairContainerSet_reserve_pair_containers(self, *args)

    def do_get_inputs(self):
        """do_get_inputs(PairContainerSet self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.PairContainerSet_do_get_inputs(self)

    def __str__(self):
        """__str__(PairContainerSet self) -> std::string"""
        return _IMP_container.PairContainerSet___str__(self)

    def __repr__(self):
        """__repr__(PairContainerSet self) -> std::string"""
        return _IMP_container.PairContainerSet___repr__(self)

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

PairContainerSet_swigregister = _IMP_container.PairContainerSet_swigregister
PairContainerSet_swigregister(PairContainerSet)

class PairsConstraint(IMP.kernel.Constraint):
    """Proxy of C++ IMP::container::PairsConstraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Constraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PairsConstraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Constraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PairsConstraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::PairsConstraint self, PairModifier before, PairModifier after, _PairContainerAdaptor c, std::string name="PairConstraint %1%") -> PairsConstraint
        __init__(IMP::container::PairsConstraint self, PairModifier before, PairModifier after, _PairContainerAdaptor c) -> PairsConstraint
        """
        this = _IMP_container.new_PairsConstraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(PairsConstraint self) -> VersionInfo"""
        return _IMP_container.PairsConstraint_get_version_info(self)

    def __str__(self):
        """__str__(PairsConstraint self) -> std::string"""
        return _IMP_container.PairsConstraint___str__(self)

    def __repr__(self):
        """__repr__(PairsConstraint self) -> std::string"""
        return _IMP_container.PairsConstraint___repr__(self)

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

PairsConstraint_swigregister = _IMP_container.PairsConstraint_swigregister
PairsConstraint_swigregister(PairsConstraint)

class PairsOptimizerState(IMP.kernel.OptimizerState):
    """Proxy of C++ IMP::container::PairsOptimizerState class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.OptimizerState]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PairsOptimizerState, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.OptimizerState]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PairsOptimizerState, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::PairsOptimizerState self, _PairContainerAdaptor c, PairModifier gf, std::string name="PairsOptimizerState %1%") -> PairsOptimizerState
        __init__(IMP::container::PairsOptimizerState self, _PairContainerAdaptor c, PairModifier gf) -> PairsOptimizerState
        """
        this = _IMP_container.new_PairsOptimizerState(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(PairsOptimizerState self) -> VersionInfo"""
        return _IMP_container.PairsOptimizerState_get_version_info(self)

    def __str__(self):
        """__str__(PairsOptimizerState self) -> std::string"""
        return _IMP_container.PairsOptimizerState___str__(self)

    def __repr__(self):
        """__repr__(PairsOptimizerState self) -> std::string"""
        return _IMP_container.PairsOptimizerState___repr__(self)

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

PairsOptimizerState_swigregister = _IMP_container.PairsOptimizerState_swigregister
PairsOptimizerState_swigregister(PairsOptimizerState)

class PairsRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::container::PairsRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PairsRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PairsRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::PairsRestraint self, PairScore ss, _PairContainerAdaptor pc, std::string name="PairsRestraint %1%") -> PairsRestraint
        __init__(IMP::container::PairsRestraint self, PairScore ss, _PairContainerAdaptor pc) -> PairsRestraint
        """
        this = _IMP_container.new_PairsRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self):
        """do_get_inputs(PairsRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.PairsRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(PairsRestraint self) -> VersionInfo"""
        return _IMP_container.PairsRestraint_get_version_info(self)

    def __str__(self):
        """__str__(PairsRestraint self) -> std::string"""
        return _IMP_container.PairsRestraint___str__(self)

    def __repr__(self):
        """__repr__(PairsRestraint self) -> std::string"""
        return _IMP_container.PairsRestraint___repr__(self)

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

PairsRestraint_swigregister = _IMP_container.PairsRestraint_swigregister
PairsRestraint_swigregister(PairsRestraint)

class QuadContainerSet(IMP.kernel.QuadContainer):
    """Proxy of C++ IMP::container::QuadContainerSet class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.QuadContainer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, QuadContainerSet, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.QuadContainer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, QuadContainerSet, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::QuadContainerSet self, Model m, std::string name="QuadContainerSet %1%") -> QuadContainerSet
        __init__(IMP::container::QuadContainerSet self, Model m) -> QuadContainerSet
        __init__(IMP::container::QuadContainerSet self, IMP::kernel::QuadContainersTemp const & pc, std::string name="QuadContainerSet %1%") -> QuadContainerSet
        __init__(IMP::container::QuadContainerSet self, IMP::kernel::QuadContainersTemp const & pc) -> QuadContainerSet
        """
        this = _IMP_container.new_QuadContainerSet(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_apply(self, *args):
        """do_apply(QuadContainerSet self, QuadModifier sm)"""
        return _IMP_container.QuadContainerSet_do_apply(self, *args)

    def get_version_info(self):
        """get_version_info(QuadContainerSet self) -> VersionInfo"""
        return _IMP_container.QuadContainerSet_get_version_info(self)

    def remove_quad_container(self, *args):
        """remove_quad_container(QuadContainerSet self, QuadContainer d)"""
        return _IMP_container.QuadContainerSet_remove_quad_container(self, *args)

    def remove_quad_containers(self, *args):
        """remove_quad_containers(QuadContainerSet self, IMP::kernel::QuadContainers const & d)"""
        return _IMP_container.QuadContainerSet_remove_quad_containers(self, *args)

    def set_quad_containers(self, *args):
        """set_quad_containers(QuadContainerSet self, IMP::kernel::QuadContainers const & ps)"""
        return _IMP_container.QuadContainerSet_set_quad_containers(self, *args)

    def set_quad_containers_order(self, *args):
        """set_quad_containers_order(QuadContainerSet self, IMP::kernel::QuadContainers const & objs)"""
        return _IMP_container.QuadContainerSet_set_quad_containers_order(self, *args)

    def add_quad_container(self, *args):
        """add_quad_container(QuadContainerSet self, QuadContainer obj) -> unsigned int"""
        return _IMP_container.QuadContainerSet_add_quad_container(self, *args)

    def add_quad_containers(self, *args):
        """add_quad_containers(QuadContainerSet self, IMP::kernel::QuadContainers const & objs)"""
        return _IMP_container.QuadContainerSet_add_quad_containers(self, *args)

    def clear_quad_containers(self):
        """clear_quad_containers(QuadContainerSet self)"""
        return _IMP_container.QuadContainerSet_clear_quad_containers(self)

    def get_number_of_quad_containers(self):
        """get_number_of_quad_containers(QuadContainerSet self) -> unsigned int"""
        return _IMP_container.QuadContainerSet_get_number_of_quad_containers(self)

    def get_has_quad_containers(self):
        """get_has_quad_containers(QuadContainerSet self) -> bool"""
        return _IMP_container.QuadContainerSet_get_has_quad_containers(self)

    def get_quad_container(self, *args):
        """get_quad_container(QuadContainerSet self, unsigned int i) -> QuadContainer"""
        return _IMP_container.QuadContainerSet_get_quad_container(self, *args)

    def get_quad_containers(self):
        """get_quad_containers(QuadContainerSet self) -> IMP::kernel::QuadContainers"""
        return _IMP_container.QuadContainerSet_get_quad_containers(self)

    def reserve_quad_containers(self, *args):
        """reserve_quad_containers(QuadContainerSet self, unsigned int sz)"""
        return _IMP_container.QuadContainerSet_reserve_quad_containers(self, *args)

    def do_get_inputs(self):
        """do_get_inputs(QuadContainerSet self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.QuadContainerSet_do_get_inputs(self)

    def __str__(self):
        """__str__(QuadContainerSet self) -> std::string"""
        return _IMP_container.QuadContainerSet___str__(self)

    def __repr__(self):
        """__repr__(QuadContainerSet self) -> std::string"""
        return _IMP_container.QuadContainerSet___repr__(self)

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

QuadContainerSet_swigregister = _IMP_container.QuadContainerSet_swigregister
QuadContainerSet_swigregister(QuadContainerSet)

class QuadsConstraint(IMP.kernel.Constraint):
    """Proxy of C++ IMP::container::QuadsConstraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Constraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, QuadsConstraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Constraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, QuadsConstraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::QuadsConstraint self, QuadModifier before, QuadModifier after, _QuadContainerAdaptor c, std::string name="QuadConstraint %1%") -> QuadsConstraint
        __init__(IMP::container::QuadsConstraint self, QuadModifier before, QuadModifier after, _QuadContainerAdaptor c) -> QuadsConstraint
        """
        this = _IMP_container.new_QuadsConstraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(QuadsConstraint self) -> VersionInfo"""
        return _IMP_container.QuadsConstraint_get_version_info(self)

    def __str__(self):
        """__str__(QuadsConstraint self) -> std::string"""
        return _IMP_container.QuadsConstraint___str__(self)

    def __repr__(self):
        """__repr__(QuadsConstraint self) -> std::string"""
        return _IMP_container.QuadsConstraint___repr__(self)

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

QuadsConstraint_swigregister = _IMP_container.QuadsConstraint_swigregister
QuadsConstraint_swigregister(QuadsConstraint)

class QuadsOptimizerState(IMP.kernel.OptimizerState):
    """Proxy of C++ IMP::container::QuadsOptimizerState class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.OptimizerState]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, QuadsOptimizerState, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.OptimizerState]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, QuadsOptimizerState, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::QuadsOptimizerState self, _QuadContainerAdaptor c, QuadModifier gf, std::string name="QuadsOptimizerState %1%") -> QuadsOptimizerState
        __init__(IMP::container::QuadsOptimizerState self, _QuadContainerAdaptor c, QuadModifier gf) -> QuadsOptimizerState
        """
        this = _IMP_container.new_QuadsOptimizerState(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(QuadsOptimizerState self) -> VersionInfo"""
        return _IMP_container.QuadsOptimizerState_get_version_info(self)

    def __str__(self):
        """__str__(QuadsOptimizerState self) -> std::string"""
        return _IMP_container.QuadsOptimizerState___str__(self)

    def __repr__(self):
        """__repr__(QuadsOptimizerState self) -> std::string"""
        return _IMP_container.QuadsOptimizerState___repr__(self)

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

QuadsOptimizerState_swigregister = _IMP_container.QuadsOptimizerState_swigregister
QuadsOptimizerState_swigregister(QuadsOptimizerState)

class QuadsRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::container::QuadsRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, QuadsRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, QuadsRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::QuadsRestraint self, QuadScore ss, _QuadContainerAdaptor pc, std::string name="QuadsRestraint %1%") -> QuadsRestraint
        __init__(IMP::container::QuadsRestraint self, QuadScore ss, _QuadContainerAdaptor pc) -> QuadsRestraint
        """
        this = _IMP_container.new_QuadsRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self):
        """do_get_inputs(QuadsRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.QuadsRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(QuadsRestraint self) -> VersionInfo"""
        return _IMP_container.QuadsRestraint_get_version_info(self)

    def __str__(self):
        """__str__(QuadsRestraint self) -> std::string"""
        return _IMP_container.QuadsRestraint___str__(self)

    def __repr__(self):
        """__repr__(QuadsRestraint self) -> std::string"""
        return _IMP_container.QuadsRestraint___repr__(self)

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

QuadsRestraint_swigregister = _IMP_container.QuadsRestraint_swigregister
QuadsRestraint_swigregister(QuadsRestraint)

class SingletonContainerSet(IMP.kernel.SingletonContainer):
    """Proxy of C++ IMP::container::SingletonContainerSet class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.SingletonContainer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SingletonContainerSet, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.SingletonContainer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SingletonContainerSet, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::SingletonContainerSet self, Model m, std::string name="SingletonContainerSet %1%") -> SingletonContainerSet
        __init__(IMP::container::SingletonContainerSet self, Model m) -> SingletonContainerSet
        __init__(IMP::container::SingletonContainerSet self, IMP::kernel::SingletonContainersTemp const & pc, std::string name="SingletonContainerSet %1%") -> SingletonContainerSet
        __init__(IMP::container::SingletonContainerSet self, IMP::kernel::SingletonContainersTemp const & pc) -> SingletonContainerSet
        """
        this = _IMP_container.new_SingletonContainerSet(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_apply(self, *args):
        """do_apply(SingletonContainerSet self, SingletonModifier sm)"""
        return _IMP_container.SingletonContainerSet_do_apply(self, *args)

    def get_version_info(self):
        """get_version_info(SingletonContainerSet self) -> VersionInfo"""
        return _IMP_container.SingletonContainerSet_get_version_info(self)

    def remove_singleton_container(self, *args):
        """remove_singleton_container(SingletonContainerSet self, SingletonContainer d)"""
        return _IMP_container.SingletonContainerSet_remove_singleton_container(self, *args)

    def remove_singleton_containers(self, *args):
        """remove_singleton_containers(SingletonContainerSet self, IMP::kernel::SingletonContainers const & d)"""
        return _IMP_container.SingletonContainerSet_remove_singleton_containers(self, *args)

    def set_singleton_containers(self, *args):
        """set_singleton_containers(SingletonContainerSet self, IMP::kernel::SingletonContainers const & ps)"""
        return _IMP_container.SingletonContainerSet_set_singleton_containers(self, *args)

    def set_singleton_containers_order(self, *args):
        """set_singleton_containers_order(SingletonContainerSet self, IMP::kernel::SingletonContainers const & objs)"""
        return _IMP_container.SingletonContainerSet_set_singleton_containers_order(self, *args)

    def add_singleton_container(self, *args):
        """add_singleton_container(SingletonContainerSet self, SingletonContainer obj) -> unsigned int"""
        return _IMP_container.SingletonContainerSet_add_singleton_container(self, *args)

    def add_singleton_containers(self, *args):
        """add_singleton_containers(SingletonContainerSet self, IMP::kernel::SingletonContainers const & objs)"""
        return _IMP_container.SingletonContainerSet_add_singleton_containers(self, *args)

    def clear_singleton_containers(self):
        """clear_singleton_containers(SingletonContainerSet self)"""
        return _IMP_container.SingletonContainerSet_clear_singleton_containers(self)

    def get_number_of_singleton_containers(self):
        """get_number_of_singleton_containers(SingletonContainerSet self) -> unsigned int"""
        return _IMP_container.SingletonContainerSet_get_number_of_singleton_containers(self)

    def get_has_singleton_containers(self):
        """get_has_singleton_containers(SingletonContainerSet self) -> bool"""
        return _IMP_container.SingletonContainerSet_get_has_singleton_containers(self)

    def get_singleton_container(self, *args):
        """get_singleton_container(SingletonContainerSet self, unsigned int i) -> SingletonContainer"""
        return _IMP_container.SingletonContainerSet_get_singleton_container(self, *args)

    def get_singleton_containers(self):
        """get_singleton_containers(SingletonContainerSet self) -> IMP::kernel::SingletonContainers"""
        return _IMP_container.SingletonContainerSet_get_singleton_containers(self)

    def reserve_singleton_containers(self, *args):
        """reserve_singleton_containers(SingletonContainerSet self, unsigned int sz)"""
        return _IMP_container.SingletonContainerSet_reserve_singleton_containers(self, *args)

    def do_get_inputs(self):
        """do_get_inputs(SingletonContainerSet self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.SingletonContainerSet_do_get_inputs(self)

    def __str__(self):
        """__str__(SingletonContainerSet self) -> std::string"""
        return _IMP_container.SingletonContainerSet___str__(self)

    def __repr__(self):
        """__repr__(SingletonContainerSet self) -> std::string"""
        return _IMP_container.SingletonContainerSet___repr__(self)

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

SingletonContainerSet_swigregister = _IMP_container.SingletonContainerSet_swigregister
SingletonContainerSet_swigregister(SingletonContainerSet)

class SingletonsConstraint(IMP.kernel.Constraint):
    """Proxy of C++ IMP::container::SingletonsConstraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Constraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SingletonsConstraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Constraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SingletonsConstraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::SingletonsConstraint self, SingletonModifier before, SingletonModifier after, _SingletonContainerAdaptor c, 
            std::string name="SingletonConstraint %1%") -> SingletonsConstraint
        __init__(IMP::container::SingletonsConstraint self, SingletonModifier before, SingletonModifier after, _SingletonContainerAdaptor c) -> SingletonsConstraint
        """
        this = _IMP_container.new_SingletonsConstraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(SingletonsConstraint self) -> VersionInfo"""
        return _IMP_container.SingletonsConstraint_get_version_info(self)

    def __str__(self):
        """__str__(SingletonsConstraint self) -> std::string"""
        return _IMP_container.SingletonsConstraint___str__(self)

    def __repr__(self):
        """__repr__(SingletonsConstraint self) -> std::string"""
        return _IMP_container.SingletonsConstraint___repr__(self)

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

SingletonsConstraint_swigregister = _IMP_container.SingletonsConstraint_swigregister
SingletonsConstraint_swigregister(SingletonsConstraint)

class SingletonsOptimizerState(IMP.kernel.OptimizerState):
    """Proxy of C++ IMP::container::SingletonsOptimizerState class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.OptimizerState]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SingletonsOptimizerState, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.OptimizerState]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SingletonsOptimizerState, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::SingletonsOptimizerState self, _SingletonContainerAdaptor c, SingletonModifier gf, std::string name="SingletonsOptimizerState %1%") -> SingletonsOptimizerState
        __init__(IMP::container::SingletonsOptimizerState self, _SingletonContainerAdaptor c, SingletonModifier gf) -> SingletonsOptimizerState
        """
        this = _IMP_container.new_SingletonsOptimizerState(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(SingletonsOptimizerState self) -> VersionInfo"""
        return _IMP_container.SingletonsOptimizerState_get_version_info(self)

    def __str__(self):
        """__str__(SingletonsOptimizerState self) -> std::string"""
        return _IMP_container.SingletonsOptimizerState___str__(self)

    def __repr__(self):
        """__repr__(SingletonsOptimizerState self) -> std::string"""
        return _IMP_container.SingletonsOptimizerState___repr__(self)

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

SingletonsOptimizerState_swigregister = _IMP_container.SingletonsOptimizerState_swigregister
SingletonsOptimizerState_swigregister(SingletonsOptimizerState)

class SingletonsRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::container::SingletonsRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SingletonsRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SingletonsRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::SingletonsRestraint self, SingletonScore ss, _SingletonContainerAdaptor pc, std::string name="SingletonsRestraint %1%") -> SingletonsRestraint
        __init__(IMP::container::SingletonsRestraint self, SingletonScore ss, _SingletonContainerAdaptor pc) -> SingletonsRestraint
        """
        this = _IMP_container.new_SingletonsRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self):
        """do_get_inputs(SingletonsRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.SingletonsRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(SingletonsRestraint self) -> VersionInfo"""
        return _IMP_container.SingletonsRestraint_get_version_info(self)

    def __str__(self):
        """__str__(SingletonsRestraint self) -> std::string"""
        return _IMP_container.SingletonsRestraint___str__(self)

    def __repr__(self):
        """__repr__(SingletonsRestraint self) -> std::string"""
        return _IMP_container.SingletonsRestraint___repr__(self)

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

SingletonsRestraint_swigregister = _IMP_container.SingletonsRestraint_swigregister
SingletonsRestraint_swigregister(SingletonsRestraint)

class TripletContainerSet(IMP.kernel.TripletContainer):
    """Proxy of C++ IMP::container::TripletContainerSet class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.TripletContainer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TripletContainerSet, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.TripletContainer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TripletContainerSet, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::TripletContainerSet self, Model m, std::string name="TripletContainerSet %1%") -> TripletContainerSet
        __init__(IMP::container::TripletContainerSet self, Model m) -> TripletContainerSet
        __init__(IMP::container::TripletContainerSet self, IMP::kernel::TripletContainersTemp const & pc, std::string name="TripletContainerSet %1%") -> TripletContainerSet
        __init__(IMP::container::TripletContainerSet self, IMP::kernel::TripletContainersTemp const & pc) -> TripletContainerSet
        """
        this = _IMP_container.new_TripletContainerSet(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_apply(self, *args):
        """do_apply(TripletContainerSet self, TripletModifier sm)"""
        return _IMP_container.TripletContainerSet_do_apply(self, *args)

    def get_version_info(self):
        """get_version_info(TripletContainerSet self) -> VersionInfo"""
        return _IMP_container.TripletContainerSet_get_version_info(self)

    def remove_triplet_container(self, *args):
        """remove_triplet_container(TripletContainerSet self, TripletContainer d)"""
        return _IMP_container.TripletContainerSet_remove_triplet_container(self, *args)

    def remove_triplet_containers(self, *args):
        """remove_triplet_containers(TripletContainerSet self, IMP::kernel::TripletContainers const & d)"""
        return _IMP_container.TripletContainerSet_remove_triplet_containers(self, *args)

    def set_triplet_containers(self, *args):
        """set_triplet_containers(TripletContainerSet self, IMP::kernel::TripletContainers const & ps)"""
        return _IMP_container.TripletContainerSet_set_triplet_containers(self, *args)

    def set_triplet_containers_order(self, *args):
        """set_triplet_containers_order(TripletContainerSet self, IMP::kernel::TripletContainers const & objs)"""
        return _IMP_container.TripletContainerSet_set_triplet_containers_order(self, *args)

    def add_triplet_container(self, *args):
        """add_triplet_container(TripletContainerSet self, TripletContainer obj) -> unsigned int"""
        return _IMP_container.TripletContainerSet_add_triplet_container(self, *args)

    def add_triplet_containers(self, *args):
        """add_triplet_containers(TripletContainerSet self, IMP::kernel::TripletContainers const & objs)"""
        return _IMP_container.TripletContainerSet_add_triplet_containers(self, *args)

    def clear_triplet_containers(self):
        """clear_triplet_containers(TripletContainerSet self)"""
        return _IMP_container.TripletContainerSet_clear_triplet_containers(self)

    def get_number_of_triplet_containers(self):
        """get_number_of_triplet_containers(TripletContainerSet self) -> unsigned int"""
        return _IMP_container.TripletContainerSet_get_number_of_triplet_containers(self)

    def get_has_triplet_containers(self):
        """get_has_triplet_containers(TripletContainerSet self) -> bool"""
        return _IMP_container.TripletContainerSet_get_has_triplet_containers(self)

    def get_triplet_container(self, *args):
        """get_triplet_container(TripletContainerSet self, unsigned int i) -> TripletContainer"""
        return _IMP_container.TripletContainerSet_get_triplet_container(self, *args)

    def get_triplet_containers(self):
        """get_triplet_containers(TripletContainerSet self) -> IMP::kernel::TripletContainers"""
        return _IMP_container.TripletContainerSet_get_triplet_containers(self)

    def reserve_triplet_containers(self, *args):
        """reserve_triplet_containers(TripletContainerSet self, unsigned int sz)"""
        return _IMP_container.TripletContainerSet_reserve_triplet_containers(self, *args)

    def do_get_inputs(self):
        """do_get_inputs(TripletContainerSet self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.TripletContainerSet_do_get_inputs(self)

    def __str__(self):
        """__str__(TripletContainerSet self) -> std::string"""
        return _IMP_container.TripletContainerSet___str__(self)

    def __repr__(self):
        """__repr__(TripletContainerSet self) -> std::string"""
        return _IMP_container.TripletContainerSet___repr__(self)

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

TripletContainerSet_swigregister = _IMP_container.TripletContainerSet_swigregister
TripletContainerSet_swigregister(TripletContainerSet)

class TripletsConstraint(IMP.kernel.Constraint):
    """Proxy of C++ IMP::container::TripletsConstraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Constraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TripletsConstraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Constraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TripletsConstraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::TripletsConstraint self, TripletModifier before, TripletModifier after, _TripletContainerAdaptor c, std::string name="TripletConstraint %1%") -> TripletsConstraint
        __init__(IMP::container::TripletsConstraint self, TripletModifier before, TripletModifier after, _TripletContainerAdaptor c) -> TripletsConstraint
        """
        this = _IMP_container.new_TripletsConstraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(TripletsConstraint self) -> VersionInfo"""
        return _IMP_container.TripletsConstraint_get_version_info(self)

    def __str__(self):
        """__str__(TripletsConstraint self) -> std::string"""
        return _IMP_container.TripletsConstraint___str__(self)

    def __repr__(self):
        """__repr__(TripletsConstraint self) -> std::string"""
        return _IMP_container.TripletsConstraint___repr__(self)

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

TripletsConstraint_swigregister = _IMP_container.TripletsConstraint_swigregister
TripletsConstraint_swigregister(TripletsConstraint)

class TripletsOptimizerState(IMP.kernel.OptimizerState):
    """Proxy of C++ IMP::container::TripletsOptimizerState class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.OptimizerState]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TripletsOptimizerState, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.OptimizerState]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TripletsOptimizerState, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::TripletsOptimizerState self, _TripletContainerAdaptor c, TripletModifier gf, std::string name="TripletsOptimizerState %1%") -> TripletsOptimizerState
        __init__(IMP::container::TripletsOptimizerState self, _TripletContainerAdaptor c, TripletModifier gf) -> TripletsOptimizerState
        """
        this = _IMP_container.new_TripletsOptimizerState(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(TripletsOptimizerState self) -> VersionInfo"""
        return _IMP_container.TripletsOptimizerState_get_version_info(self)

    def __str__(self):
        """__str__(TripletsOptimizerState self) -> std::string"""
        return _IMP_container.TripletsOptimizerState___str__(self)

    def __repr__(self):
        """__repr__(TripletsOptimizerState self) -> std::string"""
        return _IMP_container.TripletsOptimizerState___repr__(self)

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

TripletsOptimizerState_swigregister = _IMP_container.TripletsOptimizerState_swigregister
TripletsOptimizerState_swigregister(TripletsOptimizerState)

class TripletsRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::container::TripletsRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TripletsRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TripletsRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::TripletsRestraint self, TripletScore ss, _TripletContainerAdaptor pc, std::string name="TripletsRestraint %1%") -> TripletsRestraint
        __init__(IMP::container::TripletsRestraint self, TripletScore ss, _TripletContainerAdaptor pc) -> TripletsRestraint
        """
        this = _IMP_container.new_TripletsRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self):
        """do_get_inputs(TripletsRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.TripletsRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(TripletsRestraint self) -> VersionInfo"""
        return _IMP_container.TripletsRestraint_get_version_info(self)

    def __str__(self):
        """__str__(TripletsRestraint self) -> std::string"""
        return _IMP_container.TripletsRestraint___str__(self)

    def __repr__(self):
        """__repr__(TripletsRestraint self) -> std::string"""
        return _IMP_container.TripletsRestraint___repr__(self)

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

TripletsRestraint_swigregister = _IMP_container.TripletsRestraint_swigregister
TripletsRestraint_swigregister(TripletsRestraint)

class InContainerSingletonFilter(IMP.kernel.SingletonPredicate):
    """Proxy of C++ IMP::container::InContainerSingletonFilter class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.SingletonPredicate]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InContainerSingletonFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.SingletonPredicate]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InContainerSingletonFilter, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::InContainerSingletonFilter self, SingletonContainer c, std::string name="SingletonFilter %1%") -> InContainerSingletonFilter
        __init__(IMP::container::InContainerSingletonFilter self, SingletonContainer c) -> InContainerSingletonFilter
        __init__(IMP::container::InContainerSingletonFilter self, SingletonContainer c, bool handle_permutations, std::string name="SingletonFilter %1%") -> InContainerSingletonFilter
        __init__(IMP::container::InContainerSingletonFilter self, SingletonContainer c, bool handle_permutations) -> InContainerSingletonFilter
        """
        this = _IMP_container.new_InContainerSingletonFilter(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self, *args):
        """do_get_inputs(InContainerSingletonFilter self, Model m, IMP::kernel::ParticleIndexes const & pi) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.InContainerSingletonFilter_do_get_inputs(self, *args)

    def get_value(self, *args):
        """
        get_value(InContainerSingletonFilter self, Particle a) -> int
        get_value(InContainerSingletonFilter self, IMP::kernel::ParticlesTemp const & o) -> IMP::Ints
        """
        return _IMP_container.InContainerSingletonFilter_get_value(self, *args)

    def get_value_index(self, *args):
        """
        get_value_index(InContainerSingletonFilter self, Model arg2, IMP::kernel::ParticleIndex vt) -> int
        get_value_index(InContainerSingletonFilter self, Model m, IMP::kernel::ParticleIndexes const & o) -> IMP::Ints
        """
        return _IMP_container.InContainerSingletonFilter_get_value_index(self, *args)

    def get_version_info(self):
        """get_version_info(InContainerSingletonFilter self) -> VersionInfo"""
        return _IMP_container.InContainerSingletonFilter_get_version_info(self)

    def __str__(self):
        """__str__(InContainerSingletonFilter self) -> std::string"""
        return _IMP_container.InContainerSingletonFilter___str__(self)

    def __repr__(self):
        """__repr__(InContainerSingletonFilter self) -> std::string"""
        return _IMP_container.InContainerSingletonFilter___repr__(self)

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

InContainerSingletonFilter_swigregister = _IMP_container.InContainerSingletonFilter_swigregister
InContainerSingletonFilter_swigregister(InContainerSingletonFilter)

class InContainerPairFilter(IMP.kernel.PairPredicate):
    """Proxy of C++ IMP::container::InContainerPairFilter class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.PairPredicate]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InContainerPairFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.PairPredicate]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InContainerPairFilter, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::InContainerPairFilter self, PairContainer c, std::string name="PairFilter %1%") -> InContainerPairFilter
        __init__(IMP::container::InContainerPairFilter self, PairContainer c) -> InContainerPairFilter
        __init__(IMP::container::InContainerPairFilter self, PairContainer c, bool handle_permutations, std::string name="PairFilter %1%") -> InContainerPairFilter
        __init__(IMP::container::InContainerPairFilter self, PairContainer c, bool handle_permutations) -> InContainerPairFilter
        """
        this = _IMP_container.new_InContainerPairFilter(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self, *args):
        """do_get_inputs(InContainerPairFilter self, Model m, IMP::kernel::ParticleIndexes const & pi) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.InContainerPairFilter_do_get_inputs(self, *args)

    def get_value(self, *args):
        """
        get_value(InContainerPairFilter self, IMP::kernel::ParticlePair const & a) -> int
        get_value(InContainerPairFilter self, IMP::kernel::ParticlePairsTemp const & o) -> IMP::Ints
        """
        return _IMP_container.InContainerPairFilter_get_value(self, *args)

    def get_value_index(self, *args):
        """
        get_value_index(InContainerPairFilter self, Model arg2, IMP::kernel::ParticleIndexPair const & vt) -> int
        get_value_index(InContainerPairFilter self, Model m, IMP::kernel::ParticleIndexPairs const & o) -> IMP::Ints
        """
        return _IMP_container.InContainerPairFilter_get_value_index(self, *args)

    def get_version_info(self):
        """get_version_info(InContainerPairFilter self) -> VersionInfo"""
        return _IMP_container.InContainerPairFilter_get_version_info(self)

    def __str__(self):
        """__str__(InContainerPairFilter self) -> std::string"""
        return _IMP_container.InContainerPairFilter___str__(self)

    def __repr__(self):
        """__repr__(InContainerPairFilter self) -> std::string"""
        return _IMP_container.InContainerPairFilter___repr__(self)

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

InContainerPairFilter_swigregister = _IMP_container.InContainerPairFilter_swigregister
InContainerPairFilter_swigregister(InContainerPairFilter)

class InContainerTripletFilter(IMP.kernel.TripletPredicate):
    """Proxy of C++ IMP::container::InContainerTripletFilter class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.TripletPredicate]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InContainerTripletFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.TripletPredicate]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InContainerTripletFilter, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::InContainerTripletFilter self, TripletContainer c, std::string name="TripletFilter %1%") -> InContainerTripletFilter
        __init__(IMP::container::InContainerTripletFilter self, TripletContainer c) -> InContainerTripletFilter
        __init__(IMP::container::InContainerTripletFilter self, TripletContainer c, bool handle_permutations, std::string name="TripletFilter %1%") -> InContainerTripletFilter
        __init__(IMP::container::InContainerTripletFilter self, TripletContainer c, bool handle_permutations) -> InContainerTripletFilter
        """
        this = _IMP_container.new_InContainerTripletFilter(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self, *args):
        """do_get_inputs(InContainerTripletFilter self, Model m, IMP::kernel::ParticleIndexes const & pi) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.InContainerTripletFilter_do_get_inputs(self, *args)

    def get_value(self, *args):
        """
        get_value(InContainerTripletFilter self, IMP::kernel::ParticleTriplet const & a) -> int
        get_value(InContainerTripletFilter self, IMP::kernel::ParticleTripletsTemp const & o) -> IMP::Ints
        """
        return _IMP_container.InContainerTripletFilter_get_value(self, *args)

    def get_value_index(self, *args):
        """
        get_value_index(InContainerTripletFilter self, Model arg2, IMP::kernel::ParticleIndexTriplet const & vt) -> int
        get_value_index(InContainerTripletFilter self, Model m, IMP::kernel::ParticleIndexTriplets const & o) -> IMP::Ints
        """
        return _IMP_container.InContainerTripletFilter_get_value_index(self, *args)

    def get_version_info(self):
        """get_version_info(InContainerTripletFilter self) -> VersionInfo"""
        return _IMP_container.InContainerTripletFilter_get_version_info(self)

    def __str__(self):
        """__str__(InContainerTripletFilter self) -> std::string"""
        return _IMP_container.InContainerTripletFilter___str__(self)

    def __repr__(self):
        """__repr__(InContainerTripletFilter self) -> std::string"""
        return _IMP_container.InContainerTripletFilter___repr__(self)

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

InContainerTripletFilter_swigregister = _IMP_container.InContainerTripletFilter_swigregister
InContainerTripletFilter_swigregister(InContainerTripletFilter)

class InContainerQuadFilter(IMP.kernel.QuadPredicate):
    """Proxy of C++ IMP::container::InContainerQuadFilter class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.QuadPredicate]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InContainerQuadFilter, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.QuadPredicate]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InContainerQuadFilter, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::InContainerQuadFilter self, QuadContainer c, std::string name="QuadFilter %1%") -> InContainerQuadFilter
        __init__(IMP::container::InContainerQuadFilter self, QuadContainer c) -> InContainerQuadFilter
        __init__(IMP::container::InContainerQuadFilter self, QuadContainer c, bool handle_permutations, std::string name="QuadFilter %1%") -> InContainerQuadFilter
        __init__(IMP::container::InContainerQuadFilter self, QuadContainer c, bool handle_permutations) -> InContainerQuadFilter
        """
        this = _IMP_container.new_InContainerQuadFilter(*args)
        try: self.this.append(this)
        except: self.this = this
    def do_get_inputs(self, *args):
        """do_get_inputs(InContainerQuadFilter self, Model m, IMP::kernel::ParticleIndexes const & pi) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.InContainerQuadFilter_do_get_inputs(self, *args)

    def get_value(self, *args):
        """
        get_value(InContainerQuadFilter self, IMP::kernel::ParticleQuad const & a) -> int
        get_value(InContainerQuadFilter self, IMP::kernel::ParticleQuadsTemp const & o) -> IMP::Ints
        """
        return _IMP_container.InContainerQuadFilter_get_value(self, *args)

    def get_value_index(self, *args):
        """
        get_value_index(InContainerQuadFilter self, Model arg2, IMP::kernel::ParticleIndexQuad const & vt) -> int
        get_value_index(InContainerQuadFilter self, Model m, IMP::kernel::ParticleIndexQuads const & o) -> IMP::Ints
        """
        return _IMP_container.InContainerQuadFilter_get_value_index(self, *args)

    def get_version_info(self):
        """get_version_info(InContainerQuadFilter self) -> VersionInfo"""
        return _IMP_container.InContainerQuadFilter_get_version_info(self)

    def __str__(self):
        """__str__(InContainerQuadFilter self) -> std::string"""
        return _IMP_container.InContainerQuadFilter___str__(self)

    def __repr__(self):
        """__repr__(InContainerQuadFilter self) -> std::string"""
        return _IMP_container.InContainerQuadFilter___repr__(self)

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

InContainerQuadFilter_swigregister = _IMP_container.InContainerQuadFilter_swigregister
InContainerQuadFilter_swigregister(InContainerQuadFilter)

class SingletonContainerStatistics(IMP.kernel.ScoreState):
    """Proxy of C++ IMP::container::SingletonContainerStatistics class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.ScoreState]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SingletonContainerStatistics, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.ScoreState]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SingletonContainerStatistics, name)
    def __init__(self, *args): 
        """__init__(IMP::container::SingletonContainerStatistics self, _SingletonContainerAdaptor c) -> SingletonContainerStatistics"""
        this = _IMP_container.new_SingletonContainerStatistics(*args)
        try: self.this.append(this)
        except: self.this = this
    def show_statistics(self, *args):
        """show_statistics(SingletonContainerStatistics self, _ostream out)"""
        return _IMP_container.SingletonContainerStatistics_show_statistics(self, *args)

    def set_track_unique(self, *args):
        """set_track_unique(SingletonContainerStatistics self, bool tf)"""
        return _IMP_container.SingletonContainerStatistics_set_track_unique(self, *args)

    def do_before_evaluate(self):
        """do_before_evaluate(SingletonContainerStatistics self)"""
        return _IMP_container.SingletonContainerStatistics_do_before_evaluate(self)

    def do_after_evaluate(self, *args):
        """do_after_evaluate(SingletonContainerStatistics self, DerivativeAccumulator da)"""
        return _IMP_container.SingletonContainerStatistics_do_after_evaluate(self, *args)

    def do_get_inputs(self):
        """do_get_inputs(SingletonContainerStatistics self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.SingletonContainerStatistics_do_get_inputs(self)

    def do_get_outputs(self):
        """do_get_outputs(SingletonContainerStatistics self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.SingletonContainerStatistics_do_get_outputs(self)

    def get_version_info(self):
        """get_version_info(SingletonContainerStatistics self) -> VersionInfo"""
        return _IMP_container.SingletonContainerStatistics_get_version_info(self)

    def __str__(self):
        """__str__(SingletonContainerStatistics self) -> std::string"""
        return _IMP_container.SingletonContainerStatistics___str__(self)

    def __repr__(self):
        """__repr__(SingletonContainerStatistics self) -> std::string"""
        return _IMP_container.SingletonContainerStatistics___repr__(self)

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

SingletonContainerStatistics_swigregister = _IMP_container.SingletonContainerStatistics_swigregister
SingletonContainerStatistics_swigregister(SingletonContainerStatistics)

class PairContainerStatistics(IMP.kernel.ScoreState):
    """Proxy of C++ IMP::container::PairContainerStatistics class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.ScoreState]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PairContainerStatistics, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.ScoreState]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PairContainerStatistics, name)
    def __init__(self, *args): 
        """__init__(IMP::container::PairContainerStatistics self, _PairContainerAdaptor c) -> PairContainerStatistics"""
        this = _IMP_container.new_PairContainerStatistics(*args)
        try: self.this.append(this)
        except: self.this = this
    def show_statistics(self, *args):
        """show_statistics(PairContainerStatistics self, _ostream out)"""
        return _IMP_container.PairContainerStatistics_show_statistics(self, *args)

    def set_track_unique(self, *args):
        """set_track_unique(PairContainerStatistics self, bool tf)"""
        return _IMP_container.PairContainerStatistics_set_track_unique(self, *args)

    def do_before_evaluate(self):
        """do_before_evaluate(PairContainerStatistics self)"""
        return _IMP_container.PairContainerStatistics_do_before_evaluate(self)

    def do_after_evaluate(self, *args):
        """do_after_evaluate(PairContainerStatistics self, DerivativeAccumulator da)"""
        return _IMP_container.PairContainerStatistics_do_after_evaluate(self, *args)

    def do_get_inputs(self):
        """do_get_inputs(PairContainerStatistics self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.PairContainerStatistics_do_get_inputs(self)

    def do_get_outputs(self):
        """do_get_outputs(PairContainerStatistics self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.PairContainerStatistics_do_get_outputs(self)

    def get_version_info(self):
        """get_version_info(PairContainerStatistics self) -> VersionInfo"""
        return _IMP_container.PairContainerStatistics_get_version_info(self)

    def __str__(self):
        """__str__(PairContainerStatistics self) -> std::string"""
        return _IMP_container.PairContainerStatistics___str__(self)

    def __repr__(self):
        """__repr__(PairContainerStatistics self) -> std::string"""
        return _IMP_container.PairContainerStatistics___repr__(self)

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

PairContainerStatistics_swigregister = _IMP_container.PairContainerStatistics_swigregister
PairContainerStatistics_swigregister(PairContainerStatistics)

class TripletContainerStatistics(IMP.kernel.ScoreState):
    """Proxy of C++ IMP::container::TripletContainerStatistics class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.ScoreState]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TripletContainerStatistics, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.ScoreState]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TripletContainerStatistics, name)
    def __init__(self, *args): 
        """__init__(IMP::container::TripletContainerStatistics self, _TripletContainerAdaptor c) -> TripletContainerStatistics"""
        this = _IMP_container.new_TripletContainerStatistics(*args)
        try: self.this.append(this)
        except: self.this = this
    def show_statistics(self, *args):
        """show_statistics(TripletContainerStatistics self, _ostream out)"""
        return _IMP_container.TripletContainerStatistics_show_statistics(self, *args)

    def set_track_unique(self, *args):
        """set_track_unique(TripletContainerStatistics self, bool tf)"""
        return _IMP_container.TripletContainerStatistics_set_track_unique(self, *args)

    def do_before_evaluate(self):
        """do_before_evaluate(TripletContainerStatistics self)"""
        return _IMP_container.TripletContainerStatistics_do_before_evaluate(self)

    def do_after_evaluate(self, *args):
        """do_after_evaluate(TripletContainerStatistics self, DerivativeAccumulator da)"""
        return _IMP_container.TripletContainerStatistics_do_after_evaluate(self, *args)

    def do_get_inputs(self):
        """do_get_inputs(TripletContainerStatistics self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.TripletContainerStatistics_do_get_inputs(self)

    def do_get_outputs(self):
        """do_get_outputs(TripletContainerStatistics self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.TripletContainerStatistics_do_get_outputs(self)

    def get_version_info(self):
        """get_version_info(TripletContainerStatistics self) -> VersionInfo"""
        return _IMP_container.TripletContainerStatistics_get_version_info(self)

    def __str__(self):
        """__str__(TripletContainerStatistics self) -> std::string"""
        return _IMP_container.TripletContainerStatistics___str__(self)

    def __repr__(self):
        """__repr__(TripletContainerStatistics self) -> std::string"""
        return _IMP_container.TripletContainerStatistics___repr__(self)

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

TripletContainerStatistics_swigregister = _IMP_container.TripletContainerStatistics_swigregister
TripletContainerStatistics_swigregister(TripletContainerStatistics)

class QuadContainerStatistics(IMP.kernel.ScoreState):
    """Proxy of C++ IMP::container::QuadContainerStatistics class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.ScoreState]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, QuadContainerStatistics, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.ScoreState]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, QuadContainerStatistics, name)
    def __init__(self, *args): 
        """__init__(IMP::container::QuadContainerStatistics self, _QuadContainerAdaptor c) -> QuadContainerStatistics"""
        this = _IMP_container.new_QuadContainerStatistics(*args)
        try: self.this.append(this)
        except: self.this = this
    def show_statistics(self, *args):
        """show_statistics(QuadContainerStatistics self, _ostream out)"""
        return _IMP_container.QuadContainerStatistics_show_statistics(self, *args)

    def set_track_unique(self, *args):
        """set_track_unique(QuadContainerStatistics self, bool tf)"""
        return _IMP_container.QuadContainerStatistics_set_track_unique(self, *args)

    def do_before_evaluate(self):
        """do_before_evaluate(QuadContainerStatistics self)"""
        return _IMP_container.QuadContainerStatistics_do_before_evaluate(self)

    def do_after_evaluate(self, *args):
        """do_after_evaluate(QuadContainerStatistics self, DerivativeAccumulator da)"""
        return _IMP_container.QuadContainerStatistics_do_after_evaluate(self, *args)

    def do_get_inputs(self):
        """do_get_inputs(QuadContainerStatistics self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.QuadContainerStatistics_do_get_inputs(self)

    def do_get_outputs(self):
        """do_get_outputs(QuadContainerStatistics self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.QuadContainerStatistics_do_get_outputs(self)

    def get_version_info(self):
        """get_version_info(QuadContainerStatistics self) -> VersionInfo"""
        return _IMP_container.QuadContainerStatistics_get_version_info(self)

    def __str__(self):
        """__str__(QuadContainerStatistics self) -> std::string"""
        return _IMP_container.QuadContainerStatistics___str__(self)

    def __repr__(self):
        """__repr__(QuadContainerStatistics self) -> std::string"""
        return _IMP_container.QuadContainerStatistics___repr__(self)

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

QuadContainerStatistics_swigregister = _IMP_container.QuadContainerStatistics_swigregister
QuadContainerStatistics_swigregister(QuadContainerStatistics)

class EventSingletonsOptimizerState(IMP.kernel.OptimizerState):
    """Proxy of C++ IMP::container::EventSingletonsOptimizerState class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.OptimizerState]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, EventSingletonsOptimizerState, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.OptimizerState]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, EventSingletonsOptimizerState, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::EventSingletonsOptimizerState self, SingletonPredicate pred, _SingletonContainerAdaptor container, int value, int min_count, 
            int max_count, std::string name="ConstSingletonPredicate%1%") -> EventSingletonsOptimizerState
        __init__(IMP::container::EventSingletonsOptimizerState self, SingletonPredicate pred, _SingletonContainerAdaptor container, int value, int min_count, 
            int max_count) -> EventSingletonsOptimizerState
        """
        this = _IMP_container.new_EventSingletonsOptimizerState(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(EventSingletonsOptimizerState self) -> VersionInfo"""
        return _IMP_container.EventSingletonsOptimizerState_get_version_info(self)

    def __str__(self):
        """__str__(EventSingletonsOptimizerState self) -> std::string"""
        return _IMP_container.EventSingletonsOptimizerState___str__(self)

    def __repr__(self):
        """__repr__(EventSingletonsOptimizerState self) -> std::string"""
        return _IMP_container.EventSingletonsOptimizerState___repr__(self)

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

EventSingletonsOptimizerState_swigregister = _IMP_container.EventSingletonsOptimizerState_swigregister
EventSingletonsOptimizerState_swigregister(EventSingletonsOptimizerState)

class EventPairsOptimizerState(IMP.kernel.OptimizerState):
    """Proxy of C++ IMP::container::EventPairsOptimizerState class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.OptimizerState]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, EventPairsOptimizerState, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.OptimizerState]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, EventPairsOptimizerState, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::EventPairsOptimizerState self, PairPredicate pred, _PairContainerAdaptor container, int value, int min_count, int max_count, 
            std::string name="ConstPairPredicate%1%") -> EventPairsOptimizerState
        __init__(IMP::container::EventPairsOptimizerState self, PairPredicate pred, _PairContainerAdaptor container, int value, int min_count, int max_count) -> EventPairsOptimizerState
        """
        this = _IMP_container.new_EventPairsOptimizerState(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(EventPairsOptimizerState self) -> VersionInfo"""
        return _IMP_container.EventPairsOptimizerState_get_version_info(self)

    def __str__(self):
        """__str__(EventPairsOptimizerState self) -> std::string"""
        return _IMP_container.EventPairsOptimizerState___str__(self)

    def __repr__(self):
        """__repr__(EventPairsOptimizerState self) -> std::string"""
        return _IMP_container.EventPairsOptimizerState___repr__(self)

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

EventPairsOptimizerState_swigregister = _IMP_container.EventPairsOptimizerState_swigregister
EventPairsOptimizerState_swigregister(EventPairsOptimizerState)

class EventTripletsOptimizerState(IMP.kernel.OptimizerState):
    """Proxy of C++ IMP::container::EventTripletsOptimizerState class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.OptimizerState]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, EventTripletsOptimizerState, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.OptimizerState]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, EventTripletsOptimizerState, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::EventTripletsOptimizerState self, TripletPredicate pred, _TripletContainerAdaptor container, int value, int min_count, 
            int max_count, std::string name="ConstTripletPredicate%1%") -> EventTripletsOptimizerState
        __init__(IMP::container::EventTripletsOptimizerState self, TripletPredicate pred, _TripletContainerAdaptor container, int value, int min_count, 
            int max_count) -> EventTripletsOptimizerState
        """
        this = _IMP_container.new_EventTripletsOptimizerState(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(EventTripletsOptimizerState self) -> VersionInfo"""
        return _IMP_container.EventTripletsOptimizerState_get_version_info(self)

    def __str__(self):
        """__str__(EventTripletsOptimizerState self) -> std::string"""
        return _IMP_container.EventTripletsOptimizerState___str__(self)

    def __repr__(self):
        """__repr__(EventTripletsOptimizerState self) -> std::string"""
        return _IMP_container.EventTripletsOptimizerState___repr__(self)

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

EventTripletsOptimizerState_swigregister = _IMP_container.EventTripletsOptimizerState_swigregister
EventTripletsOptimizerState_swigregister(EventTripletsOptimizerState)

class EventQuadsOptimizerState(IMP.kernel.OptimizerState):
    """Proxy of C++ IMP::container::EventQuadsOptimizerState class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.OptimizerState]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, EventQuadsOptimizerState, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.OptimizerState]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, EventQuadsOptimizerState, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::EventQuadsOptimizerState self, QuadPredicate pred, _QuadContainerAdaptor container, int value, int min_count, int max_count, 
            std::string name="ConstQuadPredicate%1%") -> EventQuadsOptimizerState
        __init__(IMP::container::EventQuadsOptimizerState self, QuadPredicate pred, _QuadContainerAdaptor container, int value, int min_count, int max_count) -> EventQuadsOptimizerState
        """
        this = _IMP_container.new_EventQuadsOptimizerState(*args)
        try: self.this.append(this)
        except: self.this = this
    def get_version_info(self):
        """get_version_info(EventQuadsOptimizerState self) -> VersionInfo"""
        return _IMP_container.EventQuadsOptimizerState_get_version_info(self)

    def __str__(self):
        """__str__(EventQuadsOptimizerState self) -> std::string"""
        return _IMP_container.EventQuadsOptimizerState___str__(self)

    def __repr__(self):
        """__repr__(EventQuadsOptimizerState self) -> std::string"""
        return _IMP_container.EventQuadsOptimizerState___repr__(self)

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

EventQuadsOptimizerState_swigregister = _IMP_container.EventQuadsOptimizerState_swigregister
EventQuadsOptimizerState_swigregister(EventQuadsOptimizerState)

class PredicateSingletonsRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::container::PredicateSingletonsRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PredicateSingletonsRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PredicateSingletonsRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::PredicateSingletonsRestraint self, SingletonPredicate pred, _SingletonContainerAdaptor input, std::string name="PredicateSingletonsRestraint %1%") -> PredicateSingletonsRestraint
        __init__(IMP::container::PredicateSingletonsRestraint self, SingletonPredicate pred, _SingletonContainerAdaptor input) -> PredicateSingletonsRestraint
        """
        this = _IMP_container.new_PredicateSingletonsRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_score(self, *args):
        """set_score(PredicateSingletonsRestraint self, int predicate_value, SingletonScore score)"""
        return _IMP_container.PredicateSingletonsRestraint_set_score(self, *args)

    def set_unknown_score(self, *args):
        """set_unknown_score(PredicateSingletonsRestraint self, SingletonScore score)"""
        return _IMP_container.PredicateSingletonsRestraint_set_unknown_score(self, *args)

    def set_is_complete(self, *args):
        """set_is_complete(PredicateSingletonsRestraint self, bool tf)"""
        return _IMP_container.PredicateSingletonsRestraint_set_is_complete(self, *args)

    def get_indexes(self, *args):
        """get_indexes(PredicateSingletonsRestraint self, int predicate_value) -> IMP::kernel::ParticleIndexes"""
        return _IMP_container.PredicateSingletonsRestraint_get_indexes(self, *args)

    def do_add_score_and_derivatives(self, *args):
        """do_add_score_and_derivatives(PredicateSingletonsRestraint self, ScoreAccumulator sa)"""
        return _IMP_container.PredicateSingletonsRestraint_do_add_score_and_derivatives(self, *args)

    def do_get_inputs(self):
        """do_get_inputs(PredicateSingletonsRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.PredicateSingletonsRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(PredicateSingletonsRestraint self) -> VersionInfo"""
        return _IMP_container.PredicateSingletonsRestraint_get_version_info(self)

    def __str__(self):
        """__str__(PredicateSingletonsRestraint self) -> std::string"""
        return _IMP_container.PredicateSingletonsRestraint___str__(self)

    def __repr__(self):
        """__repr__(PredicateSingletonsRestraint self) -> std::string"""
        return _IMP_container.PredicateSingletonsRestraint___repr__(self)

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

PredicateSingletonsRestraint_swigregister = _IMP_container.PredicateSingletonsRestraint_swigregister
PredicateSingletonsRestraint_swigregister(PredicateSingletonsRestraint)

class PredicatePairsRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::container::PredicatePairsRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PredicatePairsRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PredicatePairsRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::PredicatePairsRestraint self, PairPredicate pred, _PairContainerAdaptor input, std::string name="PredicatePairsRestraint %1%") -> PredicatePairsRestraint
        __init__(IMP::container::PredicatePairsRestraint self, PairPredicate pred, _PairContainerAdaptor input) -> PredicatePairsRestraint
        """
        this = _IMP_container.new_PredicatePairsRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_score(self, *args):
        """set_score(PredicatePairsRestraint self, int predicate_value, PairScore score)"""
        return _IMP_container.PredicatePairsRestraint_set_score(self, *args)

    def set_unknown_score(self, *args):
        """set_unknown_score(PredicatePairsRestraint self, PairScore score)"""
        return _IMP_container.PredicatePairsRestraint_set_unknown_score(self, *args)

    def set_is_complete(self, *args):
        """set_is_complete(PredicatePairsRestraint self, bool tf)"""
        return _IMP_container.PredicatePairsRestraint_set_is_complete(self, *args)

    def get_indexes(self, *args):
        """get_indexes(PredicatePairsRestraint self, int predicate_value) -> IMP::kernel::ParticleIndexPairs"""
        return _IMP_container.PredicatePairsRestraint_get_indexes(self, *args)

    def do_add_score_and_derivatives(self, *args):
        """do_add_score_and_derivatives(PredicatePairsRestraint self, ScoreAccumulator sa)"""
        return _IMP_container.PredicatePairsRestraint_do_add_score_and_derivatives(self, *args)

    def do_get_inputs(self):
        """do_get_inputs(PredicatePairsRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.PredicatePairsRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(PredicatePairsRestraint self) -> VersionInfo"""
        return _IMP_container.PredicatePairsRestraint_get_version_info(self)

    def __str__(self):
        """__str__(PredicatePairsRestraint self) -> std::string"""
        return _IMP_container.PredicatePairsRestraint___str__(self)

    def __repr__(self):
        """__repr__(PredicatePairsRestraint self) -> std::string"""
        return _IMP_container.PredicatePairsRestraint___repr__(self)

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

PredicatePairsRestraint_swigregister = _IMP_container.PredicatePairsRestraint_swigregister
PredicatePairsRestraint_swigregister(PredicatePairsRestraint)

class PredicateTripletsRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::container::PredicateTripletsRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PredicateTripletsRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PredicateTripletsRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::PredicateTripletsRestraint self, TripletPredicate pred, _TripletContainerAdaptor input, std::string name="PredicateTripletsRestraint %1%") -> PredicateTripletsRestraint
        __init__(IMP::container::PredicateTripletsRestraint self, TripletPredicate pred, _TripletContainerAdaptor input) -> PredicateTripletsRestraint
        """
        this = _IMP_container.new_PredicateTripletsRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_score(self, *args):
        """set_score(PredicateTripletsRestraint self, int predicate_value, TripletScore score)"""
        return _IMP_container.PredicateTripletsRestraint_set_score(self, *args)

    def set_unknown_score(self, *args):
        """set_unknown_score(PredicateTripletsRestraint self, TripletScore score)"""
        return _IMP_container.PredicateTripletsRestraint_set_unknown_score(self, *args)

    def set_is_complete(self, *args):
        """set_is_complete(PredicateTripletsRestraint self, bool tf)"""
        return _IMP_container.PredicateTripletsRestraint_set_is_complete(self, *args)

    def get_indexes(self, *args):
        """get_indexes(PredicateTripletsRestraint self, int predicate_value) -> IMP::kernel::ParticleIndexTriplets"""
        return _IMP_container.PredicateTripletsRestraint_get_indexes(self, *args)

    def do_add_score_and_derivatives(self, *args):
        """do_add_score_and_derivatives(PredicateTripletsRestraint self, ScoreAccumulator sa)"""
        return _IMP_container.PredicateTripletsRestraint_do_add_score_and_derivatives(self, *args)

    def do_get_inputs(self):
        """do_get_inputs(PredicateTripletsRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.PredicateTripletsRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(PredicateTripletsRestraint self) -> VersionInfo"""
        return _IMP_container.PredicateTripletsRestraint_get_version_info(self)

    def __str__(self):
        """__str__(PredicateTripletsRestraint self) -> std::string"""
        return _IMP_container.PredicateTripletsRestraint___str__(self)

    def __repr__(self):
        """__repr__(PredicateTripletsRestraint self) -> std::string"""
        return _IMP_container.PredicateTripletsRestraint___repr__(self)

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

PredicateTripletsRestraint_swigregister = _IMP_container.PredicateTripletsRestraint_swigregister
PredicateTripletsRestraint_swigregister(PredicateTripletsRestraint)

class PredicateQuadsRestraint(IMP.kernel.Restraint):
    """Proxy of C++ IMP::container::PredicateQuadsRestraint class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PredicateQuadsRestraint, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.Restraint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PredicateQuadsRestraint, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::PredicateQuadsRestraint self, QuadPredicate pred, _QuadContainerAdaptor input, std::string name="PredicateQuadsRestraint %1%") -> PredicateQuadsRestraint
        __init__(IMP::container::PredicateQuadsRestraint self, QuadPredicate pred, _QuadContainerAdaptor input) -> PredicateQuadsRestraint
        """
        this = _IMP_container.new_PredicateQuadsRestraint(*args)
        try: self.this.append(this)
        except: self.this = this
    def set_score(self, *args):
        """set_score(PredicateQuadsRestraint self, int predicate_value, QuadScore score)"""
        return _IMP_container.PredicateQuadsRestraint_set_score(self, *args)

    def set_unknown_score(self, *args):
        """set_unknown_score(PredicateQuadsRestraint self, QuadScore score)"""
        return _IMP_container.PredicateQuadsRestraint_set_unknown_score(self, *args)

    def set_is_complete(self, *args):
        """set_is_complete(PredicateQuadsRestraint self, bool tf)"""
        return _IMP_container.PredicateQuadsRestraint_set_is_complete(self, *args)

    def get_indexes(self, *args):
        """get_indexes(PredicateQuadsRestraint self, int predicate_value) -> IMP::kernel::ParticleIndexQuads"""
        return _IMP_container.PredicateQuadsRestraint_get_indexes(self, *args)

    def do_add_score_and_derivatives(self, *args):
        """do_add_score_and_derivatives(PredicateQuadsRestraint self, ScoreAccumulator sa)"""
        return _IMP_container.PredicateQuadsRestraint_do_add_score_and_derivatives(self, *args)

    def do_get_inputs(self):
        """do_get_inputs(PredicateQuadsRestraint self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.PredicateQuadsRestraint_do_get_inputs(self)

    def get_version_info(self):
        """get_version_info(PredicateQuadsRestraint self) -> VersionInfo"""
        return _IMP_container.PredicateQuadsRestraint_get_version_info(self)

    def __str__(self):
        """__str__(PredicateQuadsRestraint self) -> std::string"""
        return _IMP_container.PredicateQuadsRestraint___str__(self)

    def __repr__(self):
        """__repr__(PredicateQuadsRestraint self) -> std::string"""
        return _IMP_container.PredicateQuadsRestraint___repr__(self)

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

PredicateQuadsRestraint_swigregister = _IMP_container.PredicateQuadsRestraint_swigregister
PredicateQuadsRestraint_swigregister(PredicateQuadsRestraint)

class DistributeSingletonsScoreState(IMP.kernel.ScoreState):
    """Proxy of C++ IMP::container::DistributeSingletonsScoreState class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.ScoreState]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DistributeSingletonsScoreState, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.ScoreState]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DistributeSingletonsScoreState, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::DistributeSingletonsScoreState self, _SingletonContainerAdaptor input, std::string name="DistributeSingletonsScoreState %1%") -> DistributeSingletonsScoreState
        __init__(IMP::container::DistributeSingletonsScoreState self, _SingletonContainerAdaptor input) -> DistributeSingletonsScoreState
        """
        this = _IMP_container.new_DistributeSingletonsScoreState(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_predicate(self, *args):
        """add_predicate(DistributeSingletonsScoreState self, SingletonPredicate predicate, int value) -> DynamicListSingletonContainer"""
        return _IMP_container.DistributeSingletonsScoreState_add_predicate(self, *args)

    def do_before_evaluate(self):
        """do_before_evaluate(DistributeSingletonsScoreState self)"""
        return _IMP_container.DistributeSingletonsScoreState_do_before_evaluate(self)

    def do_after_evaluate(self, *args):
        """do_after_evaluate(DistributeSingletonsScoreState self, DerivativeAccumulator da)"""
        return _IMP_container.DistributeSingletonsScoreState_do_after_evaluate(self, *args)

    def do_get_inputs(self):
        """do_get_inputs(DistributeSingletonsScoreState self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.DistributeSingletonsScoreState_do_get_inputs(self)

    def do_get_outputs(self):
        """do_get_outputs(DistributeSingletonsScoreState self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.DistributeSingletonsScoreState_do_get_outputs(self)

    def get_version_info(self):
        """get_version_info(DistributeSingletonsScoreState self) -> VersionInfo"""
        return _IMP_container.DistributeSingletonsScoreState_get_version_info(self)

    def __str__(self):
        """__str__(DistributeSingletonsScoreState self) -> std::string"""
        return _IMP_container.DistributeSingletonsScoreState___str__(self)

    def __repr__(self):
        """__repr__(DistributeSingletonsScoreState self) -> std::string"""
        return _IMP_container.DistributeSingletonsScoreState___repr__(self)

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

DistributeSingletonsScoreState_swigregister = _IMP_container.DistributeSingletonsScoreState_swigregister
DistributeSingletonsScoreState_swigregister(DistributeSingletonsScoreState)

class DistributePairsScoreState(IMP.kernel.ScoreState):
    """Proxy of C++ IMP::container::DistributePairsScoreState class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.ScoreState]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DistributePairsScoreState, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.ScoreState]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DistributePairsScoreState, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::DistributePairsScoreState self, _PairContainerAdaptor input, std::string name="DistributePairsScoreState %1%") -> DistributePairsScoreState
        __init__(IMP::container::DistributePairsScoreState self, _PairContainerAdaptor input) -> DistributePairsScoreState
        """
        this = _IMP_container.new_DistributePairsScoreState(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_predicate(self, *args):
        """add_predicate(DistributePairsScoreState self, PairPredicate predicate, int value) -> DynamicListPairContainer"""
        return _IMP_container.DistributePairsScoreState_add_predicate(self, *args)

    def do_before_evaluate(self):
        """do_before_evaluate(DistributePairsScoreState self)"""
        return _IMP_container.DistributePairsScoreState_do_before_evaluate(self)

    def do_after_evaluate(self, *args):
        """do_after_evaluate(DistributePairsScoreState self, DerivativeAccumulator da)"""
        return _IMP_container.DistributePairsScoreState_do_after_evaluate(self, *args)

    def do_get_inputs(self):
        """do_get_inputs(DistributePairsScoreState self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.DistributePairsScoreState_do_get_inputs(self)

    def do_get_outputs(self):
        """do_get_outputs(DistributePairsScoreState self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.DistributePairsScoreState_do_get_outputs(self)

    def get_version_info(self):
        """get_version_info(DistributePairsScoreState self) -> VersionInfo"""
        return _IMP_container.DistributePairsScoreState_get_version_info(self)

    def __str__(self):
        """__str__(DistributePairsScoreState self) -> std::string"""
        return _IMP_container.DistributePairsScoreState___str__(self)

    def __repr__(self):
        """__repr__(DistributePairsScoreState self) -> std::string"""
        return _IMP_container.DistributePairsScoreState___repr__(self)

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

DistributePairsScoreState_swigregister = _IMP_container.DistributePairsScoreState_swigregister
DistributePairsScoreState_swigregister(DistributePairsScoreState)

class DistributeTripletsScoreState(IMP.kernel.ScoreState):
    """Proxy of C++ IMP::container::DistributeTripletsScoreState class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.ScoreState]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DistributeTripletsScoreState, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.ScoreState]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DistributeTripletsScoreState, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::DistributeTripletsScoreState self, _TripletContainerAdaptor input, std::string name="DistributeTripletsScoreState %1%") -> DistributeTripletsScoreState
        __init__(IMP::container::DistributeTripletsScoreState self, _TripletContainerAdaptor input) -> DistributeTripletsScoreState
        """
        this = _IMP_container.new_DistributeTripletsScoreState(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_predicate(self, *args):
        """add_predicate(DistributeTripletsScoreState self, TripletPredicate predicate, int value) -> DynamicListTripletContainer"""
        return _IMP_container.DistributeTripletsScoreState_add_predicate(self, *args)

    def do_before_evaluate(self):
        """do_before_evaluate(DistributeTripletsScoreState self)"""
        return _IMP_container.DistributeTripletsScoreState_do_before_evaluate(self)

    def do_after_evaluate(self, *args):
        """do_after_evaluate(DistributeTripletsScoreState self, DerivativeAccumulator da)"""
        return _IMP_container.DistributeTripletsScoreState_do_after_evaluate(self, *args)

    def do_get_inputs(self):
        """do_get_inputs(DistributeTripletsScoreState self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.DistributeTripletsScoreState_do_get_inputs(self)

    def do_get_outputs(self):
        """do_get_outputs(DistributeTripletsScoreState self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.DistributeTripletsScoreState_do_get_outputs(self)

    def get_version_info(self):
        """get_version_info(DistributeTripletsScoreState self) -> VersionInfo"""
        return _IMP_container.DistributeTripletsScoreState_get_version_info(self)

    def __str__(self):
        """__str__(DistributeTripletsScoreState self) -> std::string"""
        return _IMP_container.DistributeTripletsScoreState___str__(self)

    def __repr__(self):
        """__repr__(DistributeTripletsScoreState self) -> std::string"""
        return _IMP_container.DistributeTripletsScoreState___repr__(self)

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

DistributeTripletsScoreState_swigregister = _IMP_container.DistributeTripletsScoreState_swigregister
DistributeTripletsScoreState_swigregister(DistributeTripletsScoreState)

class DistributeQuadsScoreState(IMP.kernel.ScoreState):
    """Proxy of C++ IMP::container::DistributeQuadsScoreState class"""
    __swig_setmethods__ = {}
    for _s in [IMP.kernel.ScoreState]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DistributeQuadsScoreState, name, value)
    __swig_getmethods__ = {}
    for _s in [IMP.kernel.ScoreState]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DistributeQuadsScoreState, name)
    def __init__(self, *args): 
        """
        __init__(IMP::container::DistributeQuadsScoreState self, _QuadContainerAdaptor input, std::string name="DistributeQuadsScoreState %1%") -> DistributeQuadsScoreState
        __init__(IMP::container::DistributeQuadsScoreState self, _QuadContainerAdaptor input) -> DistributeQuadsScoreState
        """
        this = _IMP_container.new_DistributeQuadsScoreState(*args)
        try: self.this.append(this)
        except: self.this = this
    def add_predicate(self, *args):
        """add_predicate(DistributeQuadsScoreState self, QuadPredicate predicate, int value) -> DynamicListQuadContainer"""
        return _IMP_container.DistributeQuadsScoreState_add_predicate(self, *args)

    def do_before_evaluate(self):
        """do_before_evaluate(DistributeQuadsScoreState self)"""
        return _IMP_container.DistributeQuadsScoreState_do_before_evaluate(self)

    def do_after_evaluate(self, *args):
        """do_after_evaluate(DistributeQuadsScoreState self, DerivativeAccumulator da)"""
        return _IMP_container.DistributeQuadsScoreState_do_after_evaluate(self, *args)

    def do_get_inputs(self):
        """do_get_inputs(DistributeQuadsScoreState self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.DistributeQuadsScoreState_do_get_inputs(self)

    def do_get_outputs(self):
        """do_get_outputs(DistributeQuadsScoreState self) -> IMP::kernel::ModelObjectsTemp"""
        return _IMP_container.DistributeQuadsScoreState_do_get_outputs(self)

    def get_version_info(self):
        """get_version_info(DistributeQuadsScoreState self) -> VersionInfo"""
        return _IMP_container.DistributeQuadsScoreState_get_version_info(self)

    def __str__(self):
        """__str__(DistributeQuadsScoreState self) -> std::string"""
        return _IMP_container.DistributeQuadsScoreState___str__(self)

    def __repr__(self):
        """__repr__(DistributeQuadsScoreState self) -> std::string"""
        return _IMP_container.DistributeQuadsScoreState___repr__(self)

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

DistributeQuadsScoreState_swigregister = _IMP_container.DistributeQuadsScoreState_swigregister
DistributeQuadsScoreState_swigregister(DistributeQuadsScoreState)


def create_restraint(*args):
  """
    create_restraint(PairScore ps, IMP::kernel::ParticlePair pp) -> Restraint
    create_restraint(PairScore ps, PairContainer pp) -> Restraint
    """
  return _IMP_container.create_restraint(*args)

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

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

def get_data_path(*args):
  """get_data_path(std::string fname) -> std::string"""
  return _IMP_container.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.